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

package/dist/cjs/config-bundle.js

@@ -0,0 +1,491 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookDeterministicConfigBundle = cookDeterministicConfigBundle;
+exports.verifyDeterministicConfigBundle = verifyDeterministicConfigBundle;
+exports.runDeterministicConfigBundleFixture = runDeterministicConfigBundleFixture;
+exports.runDeterministicConfigBundleParityFixture = runDeterministicConfigBundleParityFixture;
+exports.summarizeDeterministicConfigBundleFailureReasons = summarizeDeterministicConfigBundleFailureReasons;
+exports.evaluateDeterministicConfigBundleParityResult = evaluateDeterministicConfigBundleParityResult;
+const canonical_js_1 = require("./canonical.js");
+const asset_cooking_js_1 = require("./asset-cooking.js");
+function cookDeterministicConfigBundle(source, targetVersion = source.version) {
+    const migrated = migrateConfigBundle(source, targetVersion);
+    validateConfigSource(migrated);
+    const assets = (0, asset_cooking_js_1.cookDeterministicAssets)(migrated.assets);
+    const payload = {
+        version: migrated.version,
+        engineHash: migrated.engineHash,
+        schemaHash: migrated.schemaHash,
+        sessionConfig: (0, canonical_js_1.cloneCanonical)(migrated.sessionConfig),
+        simulationConfig: (0, canonical_js_1.cloneCanonical)(migrated.simulationConfig),
+        runtimeConfig: (0, canonical_js_1.cloneCanonical)(migrated.runtimeConfig),
+        playerConfig: (0, canonical_js_1.cloneCanonical)(migrated.playerConfig),
+        assetDbHash: assets.manifest.assetDbHash,
+    };
+    const bytes = (0, canonical_js_1.canonicalStringify)(payload);
+    return {
+        version: migrated.version,
+        engineHash: migrated.engineHash,
+        schemaHash: migrated.schemaHash,
+        assetDbHash: assets.manifest.assetDbHash,
+        configHash: (0, canonical_js_1.defaultChecksum)(bytes),
+        bytes,
+        assets,
+        prototypeCount: assets.manifest.prototypeIds.length,
+        migrationResult: migrated.version === source.version ? 'none' : 'migrated',
+    };
+}
+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 + (0, asset_cooking_js_1.materializePrototypeEntities)(bundle.assets, id, 1).length, 0);
+    }
+    catch {
+        return undefined;
+    }
+}
+function verifyConfigBundleIdentity(bundle) {
+    if ((0, canonical_js_1.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 || (0, canonical_js_1.canonicalStringify)(assetPayload) !== bundle.assets.bytes) {
+        return 'asset-bytes-canonical-mismatch';
+    }
+    if ((0, canonical_js_1.canonicalStringify)(assetPayload) !== (0, canonical_js_1.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: (0, canonical_js_1.defaultChecksum)({ id: asset.id, data: asset.data }),
+    }));
+    if ((0, canonical_js_1.canonicalStringify)(cookedAssetHashes) !== (0, canonical_js_1.canonicalStringify)(bundle.assets.manifest.assets)) {
+        return 'asset-manifest-entry-mismatch';
+    }
+    const recomputedAssetDbHash = (0, canonical_js_1.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;
+    }
+}
+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,
+    });
+}
+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: (0, canonical_js_1.canonicalStringify)({ tampered: true }),
+    }, {
+        engineHash: 'engine@1',
+        schemaHash: 'schema@1',
+    });
+    const tamperedAssetBytes = verifyDeterministicConfigBundle({
+        ...bundle,
+        assets: {
+            ...bundle.assets,
+            bytes: (0, canonical_js_1.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 = (0, asset_cooking_js_1.materializePrototypeEntities)(bundle.assets, 'player.prototype', 2);
+    const materializedB = (0, asset_cooking_js_1.materializePrototypeEntities)(bundle.assets, 'player.prototype', 2);
+    const inherited = (0, asset_cooking_js_1.materializePrototypeEntities)(bundle.assets, 'player.prototype', 1, {
+        componentOverrides: { Loadout: { slot: 7 } },
+    });
+    const inheritedComponents = inherited[0]?.components;
+    const map = (0, asset_cooking_js_1.materializeDeterministicMapEntities)(bundle.assets, 'map.arena');
+    const mapRepeat = (0, asset_cooking_js_1.materializeDeterministicMapEntities)(repeated.assets, 'map.arena');
+    const rebaked = (0, asset_cooking_js_1.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: (0, canonical_js_1.defaultChecksum)(materializedA) === (0, canonical_js_1.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: (0, canonical_js_1.defaultChecksum)(withoutChecksum),
+    };
+}
+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 ?? '',
+    };
+}
+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 = (0, canonical_js_1.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/cjs/creator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSyncplaySynctest = exports.createSyncplayOfflineRuntime = exports.createSchemaArtifacts = exports.defineSyncplayGame = exports.verifyReplayWithDescriptor = exports.verifyReplay = exports.exportPromotionSnapshot = exports.createSessionFromPromotionSnapshot = exports.createPauseController = exports.createOfflineSession = exports.runInstantReplay = exports.createInstantReplayRunner = exports.createDeterministicCommandTimeline = exports.defaultChecksum = exports.canonicalStringify = exports.canonicalize = void 0;
+var canonical_js_1 = require("./canonical.js");
+Object.defineProperty(exports, "canonicalize", { enumerable: true, get: function () { return canonical_js_1.canonicalize; } });
+Object.defineProperty(exports, "canonicalStringify", { enumerable: true, get: function () { return canonical_js_1.canonicalStringify; } });
+Object.defineProperty(exports, "defaultChecksum", { enumerable: true, get: function () { return canonical_js_1.defaultChecksum; } });
+var commands_js_1 = require("./commands.js");
+Object.defineProperty(exports, "createDeterministicCommandTimeline", { enumerable: true, get: function () { return commands_js_1.createDeterministicCommandTimeline; } });
+var instant_replay_js_1 = require("./instant-replay.js");
+Object.defineProperty(exports, "createInstantReplayRunner", { enumerable: true, get: function () { return instant_replay_js_1.createInstantReplayRunner; } });
+Object.defineProperty(exports, "runInstantReplay", { enumerable: true, get: function () { return instant_replay_js_1.runInstantReplay; } });
+var offline_session_js_1 = require("./offline-session.js");
+Object.defineProperty(exports, "createOfflineSession", { enumerable: true, get: function () { return offline_session_js_1.createOfflineSession; } });
+var pause_resume_js_1 = require("./pause-resume.js");
+Object.defineProperty(exports, "createPauseController", { enumerable: true, get: function () { return pause_resume_js_1.createPauseController; } });
+var session_promotion_js_1 = require("./session-promotion.js");
+Object.defineProperty(exports, "createSessionFromPromotionSnapshot", { enumerable: true, get: function () { return session_promotion_js_1.createSessionFromPromotionSnapshot; } });
+Object.defineProperty(exports, "exportPromotionSnapshot", { enumerable: true, get: function () { return session_promotion_js_1.exportPromotionSnapshot; } });
+var replay_js_1 = require("./replay.js");
+Object.defineProperty(exports, "verifyReplay", { enumerable: true, get: function () { return replay_js_1.verifyReplay; } });
+Object.defineProperty(exports, "verifyReplayWithDescriptor", { enumerable: true, get: function () { return replay_js_1.verifyReplayWithDescriptor; } });
+var schema_js_1 = require("./schema.js");
+Object.defineProperty(exports, "defineSyncplayGame", { enumerable: true, get: function () { return schema_js_1.defineSyncplayGame; } });
+var schema_artifacts_js_1 = require("./schema-artifacts.js");
+Object.defineProperty(exports, "createSchemaArtifacts", { enumerable: true, get: function () { return schema_artifacts_js_1.createSchemaArtifacts; } });
+var sdk_offline_js_1 = require("./sdk-offline.js");
+Object.defineProperty(exports, "createSyncplayOfflineRuntime", { enumerable: true, get: function () { return sdk_offline_js_1.createSyncplayOfflineRuntime; } });
+var synctest_js_1 = require("./synctest.js");
+Object.defineProperty(exports, "runSyncplaySynctest", { enumerable: true, get: function () { return synctest_js_1.runSyncplaySynctest; } });

package/dist/cjs/deterministic-primitives.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectVerticalCcdHit = detectVerticalCcdHit;
+exports.combineDeterministicPhysicsMaterial = combineDeterministicPhysicsMaterial;
+exports.cookStaticColliders = cookStaticColliders;
+exports.stepTopDownBody = stepTopDownBody;
+exports.stepKccLiteBody = stepKccLiteBody;
+exports.quantizeFpsAim = quantizeFpsAim;
+const canonical_js_1 = require("./canonical.js");
+const defaultMaterial = {
+    friction: 0,
+    restitution: 0,
+};
+function detectVerticalCcdHit(startX, endX, wallX) {
+    assertInteger(startX, 'startX');
+    assertInteger(endX, 'endX');
+    assertInteger(wallX, 'wallX');
+    return Math.min(startX, endX) <= wallX && Math.max(startX, endX) >= wallX;
+}
+function combineDeterministicPhysicsMaterial(left, right) {
+    assertInteger(left.friction, 'left.friction');
+    assertInteger(right.friction, 'right.friction');
+    assertInteger(left.restitution, 'left.restitution');
+    assertInteger(right.restitution, 'right.restitution');
+    return {
+        friction: Math.floor((left.friction + right.friction) / 2),
+        restitution: Math.max(left.restitution, right.restitution),
+    };
+}
+function cookStaticColliders(colliders) {
+    const ids = new Set();
+    const cooked = colliders.map((collider) => {
+        if (ids.has(collider.id)) {
+            throw new Error(`Duplicate static collider id ${collider.id}`);
+        }
+        ids.add(collider.id);
+        assertInteger(collider.x, `${collider.id}.x`);
+        assertInteger(collider.y, `${collider.id}.y`);
+        assertInteger(collider.halfWidth, `${collider.id}.halfWidth`);
+        assertInteger(collider.halfHeight, `${collider.id}.halfHeight`);
+        return {
+            id: collider.id,
+            x: collider.x,
+            y: collider.y,
+            halfWidth: collider.halfWidth,
+            halfHeight: collider.halfHeight,
+            material: collider.material ?? defaultMaterial,
+        };
+    }).sort((left, right) => compareUniqueStrings(left.id, right.id));
+    const bytes = (0, canonical_js_1.canonicalStringify)(cooked);
+    return {
+        schemaVersion: 1,
+        hash: (0, canonical_js_1.defaultChecksum)(cooked),
+        bytes,
+        colliders: cooked,
+    };
+}
+function compareUniqueStrings(left, right) {
+    return left < right ? -1 : 1;
+}
+function stepTopDownBody(body, input, bounds) {
+    assertInteger(input.dx, 'input.dx');
+    const dy = input.dy ?? 0;
+    assertInteger(dy, 'input.dy');
+    let x = body.x + input.dx;
+    let y = body.y + dy;
+    let vx = input.dx;
+    let vy = dy;
+    if (x < bounds.minX || x > bounds.maxX) {
+        x = clamp(x, bounds.minX, bounds.maxX);
+        vx = 0;
+    }
+    if (y < bounds.minY || y > bounds.maxY) {
+        y = clamp(y, bounds.minY, bounds.maxY);
+        vy = 0;
+    }
+    return {
+        x,
+        y,
+        vx,
+        vy,
+        grounded: body.grounded,
+    };
+}
+function stepKccLiteBody(body, input) {
+    assertInteger(input.dx, 'input.dx');
+    let x = body.x + input.dx;
+    let y = body.y + body.vy;
+    let vy = body.vy - 1;
+    if (input.jump === true && body.grounded) {
+        vy = 7;
+        y += 1;
+    }
+    if (x > 24) {
+        x = 24;
+    }
+    if (x < -24) {
+        x = -24;
+    }
+    if (y <= 0) {
+        y = 0;
+        vy = 0;
+    }
+    return {
+        x,
+        y,
+        vx: input.dx,
+        vy,
+        grounded: y === 0,
+    };
+}
+function quantizeFpsAim(previous, input) {
+    assertInteger(input.yawDelta, 'input.yawDelta');
+    assertInteger(input.pitchDelta, 'input.pitchDelta');
+    const yaw = positiveModulo(previous.yaw + input.yawDelta, 360);
+    const pitch = clamp(previous.pitch + input.pitchDelta, -89, 89);
+    return {
+        yaw,
+        pitch,
+        originX: previous.originX,
+        originY: previous.originY,
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function positiveModulo(value, modulus) {
+    return ((value % modulus) + modulus) % modulus;
+}
+function assertInteger(value, name) {
+    if (!Number.isInteger(value)) {
+        throw new Error(`${name} must be an integer`);
+    }
+}