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

package/dist/config-bundle.d.ts

@@ -0,0 +1,89 @@
+import { type CanonicalValue } from './canonical.js';
+import { type DeterministicAssetCookResult, type DeterministicAssetSource } from './asset-cooking.js';
+export interface DeterministicConfigBundleSource {
+    readonly version: number;
+    readonly engineHash: string;
+    readonly schemaHash: string;
+    readonly sessionConfig: Readonly<Record<string, CanonicalValue>>;
+    readonly simulationConfig: Readonly<Record<string, CanonicalValue>>;
+    readonly runtimeConfig: Readonly<Record<string, CanonicalValue>>;
+    readonly playerConfig: Readonly<Record<string, CanonicalValue>>;
+    readonly assets: DeterministicAssetSource;
+    readonly migrations?: readonly DeterministicConfigMigration[];
+}
+export interface DeterministicConfigMigration {
+    readonly fromVersion: number;
+    readonly toVersion: number;
+    readonly renameKeys?: Readonly<Record<string, string>>;
+    readonly renameSessionKeys?: Readonly<Record<string, string>>;
+    readonly renameSimulationKeys?: Readonly<Record<string, string>>;
+    readonly renameRuntimeKeys?: Readonly<Record<string, string>>;
+    readonly renamePlayerKeys?: Readonly<Record<string, string>>;
+    readonly renamePrototypeComponentKeys?: Readonly<Record<string, string>>;
+}
+export interface CookedDeterministicConfigBundle {
+    readonly version: number;
+    readonly engineHash: string;
+    readonly schemaHash: string;
+    readonly assetDbHash: string;
+    readonly configHash: string;
+    readonly bytes: string;
+    readonly assets: DeterministicAssetCookResult;
+    readonly prototypeCount: number;
+    readonly migrationResult: 'none' | 'migrated';
+}
+export interface DeterministicConfigBundleVerification {
+    readonly result: 'pass' | 'fail';
+    readonly configHash: string;
+    readonly assetDbHash: string;
+    readonly prototypeCount: number;
+    readonly materializedEntityCount: number;
+    readonly migrationResult: 'none' | 'migrated';
+    readonly failure?: string;
+}
+export interface DeterministicConfigBundleParityMetrics {
+    readonly result: 'pass' | 'fail';
+    readonly version: number;
+    readonly targetVersion: number;
+    readonly configHash: string;
+    readonly assetDbHash: string;
+    readonly prototypeCount: number;
+    readonly materializedEntityCount: number;
+    readonly migrationResult: 'none' | 'migrated';
+    readonly byteStable: boolean;
+    readonly staleEngineRejected: boolean;
+    readonly staleSchemaRejected: boolean;
+    readonly staleConfigRejected: boolean;
+    readonly staleAssetDbRejected: boolean;
+    readonly tamperedConfigBytesRejected: boolean;
+    readonly tamperedAssetBytesRejected: boolean;
+    readonly unsupportedFloatRejected: boolean;
+    readonly prototypeMaterializationStable: boolean;
+    readonly inheritedPrototypeMaterialized: boolean;
+    readonly dynamicCollectionsMaterialized: boolean;
+    readonly mapMaterializationStable: boolean;
+    readonly mapRebakeInvalidated: boolean;
+    readonly mapMaterializedEntityCount: number;
+    readonly mapBakeHash: string;
+    readonly failureReasons: Readonly<Record<string, string>>;
+    readonly checksum: string;
+}
+export interface DeterministicConfigBundleFailureReasonInputs {
+    readonly staleEngine: DeterministicConfigBundleVerification;
+    readonly staleSchema: DeterministicConfigBundleVerification;
+    readonly staleConfig: DeterministicConfigBundleVerification;
+    readonly staleAssetDb: DeterministicConfigBundleVerification;
+    readonly tamperedConfigBytes: DeterministicConfigBundleVerification;
+    readonly tamperedAssetBytes: DeterministicConfigBundleVerification;
+}
+export declare function cookDeterministicConfigBundle(source: DeterministicConfigBundleSource, targetVersion?: number): CookedDeterministicConfigBundle;
+export declare function verifyDeterministicConfigBundle(bundle: CookedDeterministicConfigBundle, expected: {
+    readonly engineHash: string;
+    readonly schemaHash: string;
+    readonly configHash?: string;
+    readonly assetDbHash?: string;
+}): DeterministicConfigBundleVerification;
+export declare function runDeterministicConfigBundleFixture(): DeterministicConfigBundleVerification;
+export declare function runDeterministicConfigBundleParityFixture(): DeterministicConfigBundleParityMetrics;
+export declare function summarizeDeterministicConfigBundleFailureReasons(inputs: DeterministicConfigBundleFailureReasonInputs): Readonly<Record<keyof DeterministicConfigBundleFailureReasonInputs, string>>;
+export declare function evaluateDeterministicConfigBundleParityResult(verification: DeterministicConfigBundleVerification, invariantChecks: readonly boolean[]): 'pass' | 'fail';

package/dist/config-bundle.js

@@ -0,0 +1,483 @@
+import { canonicalStringify, cloneCanonical, defaultChecksum } from './canonical.js';
+import { cookDeterministicAssets, materializeDeterministicMapEntities, materializePrototypeEntities, } from './asset-cooking.js';
+export function cookDeterministicConfigBundle(source, targetVersion = source.version) {
+    const migrated = migrateConfigBundle(source, targetVersion);
+    validateConfigSource(migrated);
+    const assets = cookDeterministicAssets(migrated.assets);
+    const payload = {
+        version: migrated.version,
+        engineHash: migrated.engineHash,
+        schemaHash: migrated.schemaHash,
+        sessionConfig: cloneCanonical(migrated.sessionConfig),
+        simulationConfig: cloneCanonical(migrated.simulationConfig),
+        runtimeConfig: cloneCanonical(migrated.runtimeConfig),
+        playerConfig: cloneCanonical(migrated.playerConfig),
+        assetDbHash: assets.manifest.assetDbHash,
+    };
+    const bytes = canonicalStringify(payload);
+    return {
+        version: migrated.version,
+        engineHash: migrated.engineHash,
+        schemaHash: migrated.schemaHash,
+        assetDbHash: assets.manifest.assetDbHash,
+        configHash: defaultChecksum(bytes),
+        bytes,
+        assets,
+        prototypeCount: assets.manifest.prototypeIds.length,
+        migrationResult: migrated.version === source.version ? 'none' : 'migrated',
+    };
+}
+export function verifyDeterministicConfigBundle(bundle, expected) {
+    const identityFailure = verifyConfigBundleIdentity(bundle);
+    const materializedEntityCount = identityFailure === undefined ? materializedEntityCountOrUndefined(bundle) : undefined;
+    const base = {
+        configHash: bundle.configHash,
+        assetDbHash: bundle.assetDbHash,
+        prototypeCount: bundle.prototypeCount,
+        materializedEntityCount: materializedEntityCount ?? 0,
+        migrationResult: bundle.migrationResult,
+    };
+    if (identityFailure !== undefined) {
+        return { ...base, result: 'fail', failure: identityFailure };
+    }
+    if (materializedEntityCount === undefined) {
+        return { ...base, result: 'fail', failure: 'prototype-materialization-mismatch' };
+    }
+    if (bundle.engineHash !== expected.engineHash) {
+        return { ...base, result: 'fail', failure: 'stale-engine-hash' };
+    }
+    if (bundle.schemaHash !== expected.schemaHash) {
+        return { ...base, result: 'fail', failure: 'stale-schema-hash' };
+    }
+    if (expected.configHash !== undefined && bundle.configHash !== expected.configHash) {
+        return { ...base, result: 'fail', failure: 'stale-config-hash' };
+    }
+    if (expected.assetDbHash !== undefined && bundle.assetDbHash !== expected.assetDbHash) {
+        return { ...base, result: 'fail', failure: 'stale-asset-db-hash' };
+    }
+    return { ...base, result: 'pass' };
+}
+function materializedEntityCountOrUndefined(bundle) {
+    try {
+        return bundle.assets.manifest.prototypeIds.reduce((sum, id) => sum + materializePrototypeEntities(bundle.assets, id, 1).length, 0);
+    }
+    catch {
+        return undefined;
+    }
+}
+function verifyConfigBundleIdentity(bundle) {
+    if (defaultChecksum(bundle.bytes) !== bundle.configHash) {
+        return 'config-bytes-hash-mismatch';
+    }
+    const payload = parseJsonOrUndefined(bundle.bytes);
+    if (!isRecord(payload)) {
+        return 'config-bytes-payload-invalid';
+    }
+    if (payload.version !== bundle.version) {
+        return 'config-bytes-version-mismatch';
+    }
+    if (payload.engineHash !== bundle.engineHash) {
+        return 'config-bytes-engine-hash-mismatch';
+    }
+    if (payload.schemaHash !== bundle.schemaHash) {
+        return 'config-bytes-schema-hash-mismatch';
+    }
+    if (payload.assetDbHash !== bundle.assetDbHash) {
+        return 'config-bytes-asset-db-hash-mismatch';
+    }
+    if (!isRecord(payload.sessionConfig)) {
+        return 'config-bytes-session-config-mismatch';
+    }
+    if (!isRecord(payload.simulationConfig)) {
+        return 'config-bytes-simulation-config-mismatch';
+    }
+    if (!isRecord(payload.runtimeConfig)) {
+        return 'config-bytes-runtime-config-mismatch';
+    }
+    if (!isRecord(payload.playerConfig)) {
+        return 'config-bytes-player-config-mismatch';
+    }
+    const assetPayload = parseJsonOrUndefined(bundle.assets.bytes);
+    if (assetPayload === undefined || canonicalStringify(assetPayload) !== bundle.assets.bytes) {
+        return 'asset-bytes-canonical-mismatch';
+    }
+    if (canonicalStringify(assetPayload) !== canonicalStringify({ manifest: bundle.assets.manifest, assets: bundle.assets.cookedAssets })) {
+        return 'asset-bytes-content-mismatch';
+    }
+    const cookedAssetHashes = bundle.assets.cookedAssets.map((asset) => ({
+        id: asset.id,
+        type: asset.type,
+        hash: defaultChecksum({ id: asset.id, data: asset.data }),
+    }));
+    if (canonicalStringify(cookedAssetHashes) !== canonicalStringify(bundle.assets.manifest.assets)) {
+        return 'asset-manifest-entry-mismatch';
+    }
+    const recomputedAssetDbHash = defaultChecksum({
+        engineVersion: bundle.assets.manifest.engineVersion,
+        schemaHash: bundle.assets.manifest.schemaHash,
+        dependencyHash: bundle.assets.manifest.dependencyHash,
+        dependencies: bundle.assets.manifest.dependencies,
+        cookedAssets: bundle.assets.cookedAssets,
+    });
+    if (recomputedAssetDbHash !== bundle.assetDbHash || recomputedAssetDbHash !== bundle.assets.manifest.assetDbHash) {
+        return 'asset-db-hash-mismatch';
+    }
+    if (bundle.prototypeCount !== bundle.assets.manifest.prototypeIds.length) {
+        return 'prototype-count-mismatch';
+    }
+    if (bundle.assets.manifest.assetCount !== bundle.assets.cookedAssets.length) {
+        return 'asset-count-mismatch';
+    }
+    return undefined;
+}
+function parseJsonOrUndefined(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function runDeterministicConfigBundleFixture() {
+    const bundle = cookDeterministicConfigBundle({
+        version: 1,
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+        sessionConfig: { tickRate: 60, players: 128 },
+        simulationConfig: { numericModeV1: 'fixed', rollback: true },
+        runtimeConfig: { maxRollbackFrames: 12 },
+        playerConfig: { defaultTeam: 'blue' },
+        assets: {
+            schemaVersion: 1,
+            engineVersion: 'engine@1',
+            assets: [
+                { id: 'material.default', type: 'physics-material', friction: 1, restitution: 0 },
+                { id: 'player.prototype', type: 'prototype', prototype: true, references: ['material.default'], components: { hp: 100, speed: 12 } },
+            ],
+        },
+        migrations: [{ fromVersion: 1, toVersion: 2, renameKeys: { numericModeV1: 'numericMode' } }],
+    }, 2);
+    return verifyDeterministicConfigBundle(bundle, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+        configHash: bundle.configHash,
+        assetDbHash: bundle.assetDbHash,
+    });
+}
+export function runDeterministicConfigBundleParityFixture() {
+    const source = createConfigBundleParitySource();
+    const targetVersion = 2;
+    const bundle = cookDeterministicConfigBundle(source, targetVersion);
+    const repeated = cookDeterministicConfigBundle(source, targetVersion);
+    const verification = verifyDeterministicConfigBundle(bundle, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+        configHash: bundle.configHash,
+        assetDbHash: bundle.assetDbHash,
+    });
+    const staleEngine = verifyDeterministicConfigBundle(bundle, {
+        engineHash: 'engine@old',
+        schemaHash: 'schema@1',
+    });
+    const staleSchema = verifyDeterministicConfigBundle(bundle, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@old',
+    });
+    const staleConfig = verifyDeterministicConfigBundle(bundle, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+        configHash: 'stale-config',
+    });
+    const staleAssetDb = verifyDeterministicConfigBundle(bundle, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+        assetDbHash: 'stale-asset-db',
+    });
+    const tamperedConfigBytes = verifyDeterministicConfigBundle({
+        ...bundle,
+        bytes: canonicalStringify({ tampered: true }),
+    }, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+    });
+    const tamperedAssetBytes = verifyDeterministicConfigBundle({
+        ...bundle,
+        assets: {
+            ...bundle.assets,
+            bytes: canonicalStringify({ manifest: bundle.assets.manifest, assets: [] }),
+        },
+    }, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+    });
+    const unsupportedFloatRejected = throws(() => cookDeterministicConfigBundle({
+        ...source,
+        sessionConfig: { ...source.sessionConfig, badFloat: 1.5 },
+    }, targetVersion));
+    const validConfigAccepted = !throws(() => cookDeterministicConfigBundle(source, targetVersion));
+    const materializedA = materializePrototypeEntities(bundle.assets, 'player.prototype', 2);
+    const materializedB = materializePrototypeEntities(bundle.assets, 'player.prototype', 2);
+    const inherited = materializePrototypeEntities(bundle.assets, 'player.prototype', 1, {
+        componentOverrides: { Loadout: { slot: 7 } },
+    });
+    const inheritedComponents = inherited[0]?.components;
+    const map = materializeDeterministicMapEntities(bundle.assets, 'map.arena');
+    const mapRepeat = materializeDeterministicMapEntities(repeated.assets, 'map.arena');
+    const rebaked = materializeDeterministicMapEntities(cookDeterministicConfigBundle({
+        ...source,
+        assets: {
+            ...source.assets,
+            assets: source.assets.assets.map((asset) => asset.id === 'map.arena'
+                ? { ...asset, spawns: [{ prototypeRef: 'player.prototype', count: 3, startEntityId: 100, overrides: { hp: 80 } }] }
+                : asset),
+        },
+    }, targetVersion).assets, 'map.arena');
+    const failureReasons = {
+        ...summarizeDeterministicConfigBundleFailureReasons({
+            staleEngine,
+            staleSchema,
+            staleConfig,
+            staleAssetDb,
+            tamperedConfigBytes,
+            tamperedAssetBytes,
+        }),
+    };
+    const withoutChecksum = {
+        version: source.version,
+        targetVersion,
+        configHash: bundle.configHash,
+        assetDbHash: bundle.assetDbHash,
+        prototypeCount: bundle.prototypeCount,
+        materializedEntityCount: verification.materializedEntityCount,
+        migrationResult: bundle.migrationResult,
+        byteStable: bundle.configHash === repeated.configHash && bundle.assetDbHash === repeated.assetDbHash && bundle.bytes === repeated.bytes,
+        staleEngineRejected: staleEngine.failure === 'stale-engine-hash',
+        staleSchemaRejected: staleSchema.failure === 'stale-schema-hash',
+        staleConfigRejected: staleConfig.failure === 'stale-config-hash',
+        staleAssetDbRejected: staleAssetDb.failure === 'stale-asset-db-hash',
+        tamperedConfigBytesRejected: tamperedConfigBytes.failure === 'config-bytes-hash-mismatch',
+        tamperedAssetBytesRejected: tamperedAssetBytes.failure === 'asset-bytes-content-mismatch',
+        unsupportedFloatRejected,
+        prototypeMaterializationStable: defaultChecksum(materializedA) === defaultChecksum(materializedB) && materializedA.length === 2,
+        inheritedPrototypeMaterialized: inheritedComponents?.hp === 80
+            && inheritedComponents.speed === 12
+            && inheritedComponents.numericMode === 'fixed'
+            && inheritedComponents.Loadout?.slot === 7,
+        dynamicCollectionsMaterialized: Array.isArray(inheritedComponents?.Inventory?.items)
+            && inheritedComponents.Inventory.items[0] === 'weapon.sword'
+            && Array.isArray(inheritedComponents.Inventory.tags)
+            && inheritedComponents.Inventory.tags.join(',') === 'player,spawned',
+        mapMaterializationStable: map.mapBakeHash === mapRepeat.mapBakeHash && map.materializedEntityCount === 2,
+        mapRebakeInvalidated: map.mapBakeHash !== rebaked.mapBakeHash,
+        mapMaterializedEntityCount: map.materializedEntityCount,
+        mapBakeHash: map.mapBakeHash,
+        failureReasons,
+    };
+    const invariantChecks = [
+        withoutChecksum.byteStable,
+        withoutChecksum.staleEngineRejected,
+        withoutChecksum.staleSchemaRejected,
+        withoutChecksum.staleConfigRejected,
+        withoutChecksum.staleAssetDbRejected,
+        withoutChecksum.tamperedConfigBytesRejected,
+        withoutChecksum.tamperedAssetBytesRejected,
+        withoutChecksum.unsupportedFloatRejected,
+        validConfigAccepted,
+        withoutChecksum.prototypeMaterializationStable,
+        withoutChecksum.inheritedPrototypeMaterialized,
+        withoutChecksum.dynamicCollectionsMaterialized,
+        withoutChecksum.mapMaterializationStable,
+        withoutChecksum.mapRebakeInvalidated,
+    ];
+    const result = evaluateDeterministicConfigBundleParityResult(verification, invariantChecks);
+    return {
+        result,
+        ...withoutChecksum,
+        checksum: defaultChecksum(withoutChecksum),
+    };
+}
+export function summarizeDeterministicConfigBundleFailureReasons(inputs) {
+    return {
+        staleEngine: inputs.staleEngine.failure ?? '',
+        staleSchema: inputs.staleSchema.failure ?? '',
+        staleConfig: inputs.staleConfig.failure ?? '',
+        staleAssetDb: inputs.staleAssetDb.failure ?? '',
+        tamperedConfigBytes: inputs.tamperedConfigBytes.failure ?? '',
+        tamperedAssetBytes: inputs.tamperedAssetBytes.failure ?? '',
+    };
+}
+export function evaluateDeterministicConfigBundleParityResult(verification, invariantChecks) {
+    return verification.result === 'pass'
+        && invariantChecks.every((value) => value)
+        ? 'pass'
+        : 'fail';
+}
+function createConfigBundleParitySource() {
+    return {
+        version: 1,
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+        sessionConfig: { tickRate: 60, players: 128 },
+        simulationConfig: { numericModeV1: 'fixed', rollback: true },
+        runtimeConfig: { maxRollbackFrames: 12, snapshotStride: 4 },
+        playerConfig: { defaultTeam: 'blue', maxSlots: 128 },
+        assets: {
+            schemaVersion: 1,
+            engineVersion: 'engine@1',
+            assets: [
+                { id: 'material.default', type: 'physics-material', friction: 1, restitution: 0 },
+                { id: 'material.ice', type: 'physics-material', friction: 0, restitution: 1 },
+                {
+                    id: 'base.prototype',
+                    type: 'prototype',
+                    prototype: true,
+                    references: ['material.default'],
+                    components: {
+                        hp: 100,
+                        speed: 12,
+                        numericModeV1: 'fixed',
+                        Inventory: {
+                            items: { collection: 'list', values: ['weapon.sword'] },
+                            tags: { collection: 'set', values: ['spawned', 'player', 'spawned'] },
+                        },
+                    },
+                },
+                {
+                    id: 'weapon.sword',
+                    type: 'item',
+                },
+                {
+                    id: 'player.prototype',
+                    type: 'prototype',
+                    prototype: true,
+                    extendsRef: 'base.prototype',
+                    references: ['base.prototype'],
+                    components: { hp: 80 },
+                },
+                {
+                    id: 'map.arena',
+                    type: 'map',
+                    references: ['player.prototype'],
+                    spawns: [{ prototypeRef: 'player.prototype', count: 2, startEntityId: 100, overrides: { hp: 80 } }],
+                },
+            ],
+        },
+        migrations: [{
+                fromVersion: 1,
+                toVersion: 2,
+                renameSimulationKeys: { numericModeV1: 'numericMode' },
+                renamePrototypeComponentKeys: { numericModeV1: 'numericMode' },
+            }],
+    };
+}
+function migrateConfigBundle(source, targetVersion) {
+    let current = cloneCanonical(source);
+    validateUniqueMigrations(current.migrations ?? []);
+    while (current.version < targetVersion) {
+        const migration = current.migrations?.find((candidate) => candidate.fromVersion === current.version);
+        if (migration === undefined) {
+            throw new Error(`Missing config migration from ${current.version}`);
+        }
+        current = {
+            ...current,
+            version: migration.toVersion,
+            sessionConfig: renameConfigKeys(current.sessionConfig, migration.renameSessionKeys ?? {}),
+            simulationConfig: renameConfigKeys(current.simulationConfig, migration.renameSimulationKeys ?? migration.renameKeys ?? {}),
+            runtimeConfig: renameConfigKeys(current.runtimeConfig, migration.renameRuntimeKeys ?? {}),
+            playerConfig: renameConfigKeys(current.playerConfig, migration.renamePlayerKeys ?? {}),
+            assets: renamePrototypeComponentKeys(current.assets, migration.renamePrototypeComponentKeys ?? {}),
+        };
+    }
+    if (current.version !== targetVersion) {
+        throw new Error(`Unsupported config version ${current.version}`);
+    }
+    return current;
+}
+function renamePrototypeComponentKeys(assets, renames) {
+    if (stableKeys(renames).length === 0) {
+        return assets;
+    }
+    return {
+        ...assets,
+        assets: assets.assets.map((asset) => {
+            if (asset.prototype !== true || !isRecord(asset.components)) {
+                return asset;
+            }
+            return {
+                ...asset,
+                components: renameConfigKeys(asset.components, renames),
+            };
+        }),
+    };
+}
+function validateUniqueMigrations(migrations) {
+    const fromVersions = new Set();
+    for (const migration of migrations) {
+        if (!Number.isInteger(migration.fromVersion) || !Number.isInteger(migration.toVersion)) {
+            throw new Error('Config migration versions must be integers');
+        }
+        if (migration.toVersion <= migration.fromVersion) {
+            throw new Error(`Config migration from ${migration.fromVersion} must advance to a higher version`);
+        }
+        if (fromVersions.has(migration.fromVersion)) {
+            throw new Error(`Duplicate config migration from ${migration.fromVersion}`);
+        }
+        fromVersions.add(migration.fromVersion);
+    }
+}
+function renameConfigKeys(config, renames) {
+    const next = {};
+    for (const key of stableKeys(config)) {
+        const renamed = renames[key] ?? key;
+        if (Object.prototype.hasOwnProperty.call(next, renamed)) {
+            throw new Error(`Config migration key collision at ${renamed}`);
+        }
+        next[renamed] = config[key];
+    }
+    return next;
+}
+function validateConfigSource(source) {
+    if (source.engineHash.length === 0 || source.schemaHash.length === 0) {
+        throw new Error('Config bundle requires engine and schema hashes');
+    }
+    rejectUnsupportedFloats(source.sessionConfig, 'sessionConfig');
+    rejectUnsupportedFloats(source.simulationConfig, 'simulationConfig');
+    rejectUnsupportedFloats(source.runtimeConfig, 'runtimeConfig');
+    rejectUnsupportedFloats(source.playerConfig, 'playerConfig');
+}
+function rejectUnsupportedFloats(value, path) {
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value)) {
+            throw new Error(`Unsupported float in config bundle at ${path}`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => rejectUnsupportedFloats(entry, `${path}[${index}]`));
+        return;
+    }
+    if (value !== null && typeof value === 'object') {
+        const record = value;
+        for (const key of stableKeys(record)) {
+            rejectUnsupportedFloats(record[key], `${path}.${key}`);
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stableKeys(record) {
+    return Object.keys(record).sort(compareStrings);
+}
+function compareStrings(left, right) {
+    return Number(left > right) - Number(left < right);
+}
+function throws(action) {
+    try {
+        action();
+        return false;
+    }
+    catch {
+        return true;
+    }
+}

package/dist/creator.d.ts

@@ -0,0 +1,20 @@
+export { canonicalize, canonicalStringify, defaultChecksum } from './canonical.js';
+export { createDeterministicCommandTimeline } from './commands.js';
+export { createInstantReplayRunner, runInstantReplay } from './instant-replay.js';
+export { createOfflineSession } from './offline-session.js';
+export { createPauseController } from './pause-resume.js';
+export { createSessionFromPromotionSnapshot, exportPromotionSnapshot } from './session-promotion.js';
+export { verifyReplay, verifyReplayWithDescriptor } from './replay.js';
+export { defineSyncplayGame } from './schema.js';
+export { createSchemaArtifacts } from './schema-artifacts.js';
+export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export { runSyncplaySynctest } from './synctest.js';
+export type { SyncplaySynctestConfig, SyncplaySynctestDivergence, SyncplaySynctestInputFuzz, SyncplaySynctestPhase, SyncplaySynctestResult, } from './synctest.js';
+export type { CanonicalValue } from './canonical.js';
+export type { DeterministicCommandChannelDescriptor, DeterministicCommandTimeline, DeterministicCommandTimelineConfig, DeterministicCommandTimelineSnapshot, DeterministicPlayerCommand, DeterministicRejectedCommand, } from './commands.js';
+export type { OfflineSession, RecordedChecksum, RecordedCommandFrame, RecordedDebugEvent, RecordedInputFlags, RecordedInputFrame, ReplayFile, ReplayRecordingMode, ReplayVerificationResult, TickRate, DeterministicSessionConfig, DeterministicStep, DeterministicStepContext, } from './types.js';
+export type { AssetDescriptor, CommandChannelDescriptor, ConfigDescriptor, DeterministicGameDescriptor, EventDescriptor, InputFieldDescriptor, NumericMode, PrototypeDescriptor, SchemaFieldDescriptor, SchemaFieldKind, StateFieldDescriptor, SystemDescriptor, ValidatedDeterministicGameDescriptor, } from './schema.js';
+export type { DeterministicOfflineFrame, DeterministicOfflineRuntime, DeterministicOfflineRuntimeConfig, } from './sdk-offline.js';
+export type { DeterministicSchemaArtifacts, SchemaFrameDump, } from './schema-artifacts.js';
+export type { InstantReplayInputFrame, InstantReplayResult, InstantReplayRunner, InstantReplayRunnerOptions, InstantReplayRunOptions, RunInstantReplayOptions, } from './instant-replay.js';
+export type { DeterministicPauseController, DeterministicPauseState, DeterministicPauseStatus, PauseControllerOptions, PauseWrappedState, } from './pause-resume.js';

package/dist/creator.js

@@ -0,0 +1,11 @@
+export { canonicalize, canonicalStringify, defaultChecksum } from './canonical.js';
+export { createDeterministicCommandTimeline } from './commands.js';
+export { createInstantReplayRunner, runInstantReplay } from './instant-replay.js';
+export { createOfflineSession } from './offline-session.js';
+export { createPauseController } from './pause-resume.js';
+export { createSessionFromPromotionSnapshot, exportPromotionSnapshot } from './session-promotion.js';
+export { verifyReplay, verifyReplayWithDescriptor } from './replay.js';
+export { defineSyncplayGame } from './schema.js';
+export { createSchemaArtifacts } from './schema-artifacts.js';
+export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export { runSyncplaySynctest } from './synctest.js';

package/dist/deterministic-primitives.d.ts

@@ -0,0 +1,59 @@
+export interface DeterministicPhysicsMaterial {
+    readonly friction: number;
+    readonly restitution: number;
+}
+export interface DeterministicStaticCollider {
+    readonly id: string;
+    readonly x: number;
+    readonly y: number;
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+    readonly material?: DeterministicPhysicsMaterial;
+}
+export interface CookedDeterministicStaticCollider {
+    readonly id: string;
+    readonly x: number;
+    readonly y: number;
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+    readonly material: DeterministicPhysicsMaterial;
+}
+export interface CookedStaticColliderSet {
+    readonly schemaVersion: 1;
+    readonly hash: string;
+    readonly bytes: string;
+    readonly colliders: readonly CookedDeterministicStaticCollider[];
+}
+export interface MovementBody {
+    readonly x: number;
+    readonly y: number;
+    readonly vx: number;
+    readonly vy: number;
+    readonly grounded: boolean;
+}
+export interface MovementInput {
+    readonly dx: number;
+    readonly dy?: number;
+    readonly jump?: boolean;
+}
+export interface FpsAimInput {
+    readonly yawDelta: number;
+    readonly pitchDelta: number;
+}
+export interface QuantizedFpsAim {
+    readonly yaw: number;
+    readonly pitch: number;
+    readonly originX: number;
+    readonly originY: number;
+}
+export declare function detectVerticalCcdHit(startX: number, endX: number, wallX: number): boolean;
+export declare function combineDeterministicPhysicsMaterial(left: DeterministicPhysicsMaterial, right: DeterministicPhysicsMaterial): DeterministicPhysicsMaterial;
+export declare function cookStaticColliders(colliders: readonly DeterministicStaticCollider[]): CookedStaticColliderSet;
+export declare function stepTopDownBody(body: MovementBody, input: MovementInput, bounds: {
+    readonly minX: number;
+    readonly maxX: number;
+    readonly minY: number;
+    readonly maxY: number;
+}): MovementBody;
+export declare function stepKccLiteBody(body: MovementBody, input: MovementInput): MovementBody;
+export declare function quantizeFpsAim(previous: QuantizedFpsAim, input: FpsAimInput): QuantizedFpsAim;