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

package/dist/sample-scenes.js

@@ -0,0 +1,745 @@
+import { cloneCanonical, defaultChecksum } from './canonical.js';
+import { cookDeterministicAnimation, createDeterministicAnimationRuntimeState, stepDeterministicAnimation } from './animation.js';
+import { compileDeterministicBotDocument, traceDeterministicBotDocument } from './bot-documents.js';
+import { createDeterministicCommandTimeline } from './commands.js';
+import { cookDeterministicConfigBundle } from './config-bundle.js';
+import { createDeterministicFrameRuntime } from './engine-runtime.js';
+import { stepDeterministicKcc3D } from './movement3d.js';
+import { cookDeterministicNavmesh, stepDeterministicNavmeshAgents } from './navmesh.js';
+import { createDeterministicPhysicsWorld3D, stepDeterministicPhysicsWorld3D } from './physics3d.js';
+import { createDeterministicReplayBundle, verifyDeterministicFrameRuntimeReplayBundle } from './replay-bundle.js';
+export const deterministicSampleSceneIds = [
+    'asteroids',
+    'simple-fps',
+    'twin-stick',
+    'platform-shooter',
+    'arena-brawler',
+    'vehicle',
+    'mini-golf',
+    'waiting-room',
+    'boat-water',
+    'animator',
+];
+export function runDeterministicSampleScene(sampleId, frames, seed) {
+    const control = stepSampleScene(sampleId, frames, seed, -1);
+    const restored = stepSampleScene(sampleId, frames, seed, Math.floor(frames / 2));
+    const subsystemMetrics = sampleSubsystemProofMetrics(sampleId, Math.min(frames, 48), seed);
+    const metrics = {
+        ...restored.metrics,
+        ...subsystemMetrics,
+    };
+    return {
+        sampleId,
+        checksum: defaultChecksum({ sampleId, baseChecksum: control.checksum, subsystemMetrics }),
+        rollbackChecksum: defaultChecksum({ sampleId, baseChecksum: restored.checksum, subsystemMetrics }),
+        events: restored.events,
+        invariants: sampleInvariants(sampleId, metrics, control.checksum === restored.checksum),
+        metrics,
+    };
+}
+export function runAllDeterministicSampleScenes(frames, seed) {
+    return deterministicSampleSceneIds.map((sampleId, index) => runDeterministicSampleScene(sampleId, frames, seed + index));
+}
+export function createDeterministicSampleSceneCertificationTrace(frames, players, seed) {
+    const samples = deterministicSampleSceneIds.map((sampleId, index) => createDeterministicSampleSceneTrace(sampleId, frames, seed + index));
+    const integratedProof = runDeterministicIntegratedHeadlessScene(Math.min(frames, 1_000), Math.min(players, 128), seed + 991);
+    const integrated = {
+        checksum: integratedProof.checksum,
+        replayChecksum: integratedProof.replayChecksum,
+        rollbackChecksum: integratedProof.rollbackChecksum,
+        replayVerified: integratedProof.replayVerified,
+        rollbackEquivalent: integratedProof.rollbackEquivalent,
+        replaySnapshots: integratedProof.metrics.replaySnapshots,
+        commandsAccepted: integratedProof.metrics.commandsAccepted,
+        physicsContacts: integratedProof.metrics.physicsContacts,
+        kccCorrections: integratedProof.metrics.kccCorrections,
+        navReplans: integratedProof.metrics.navReplans,
+        botTraceRows: integratedProof.metrics.botTraceRows,
+        animationEvents: integratedProof.metrics.animationEvents,
+    };
+    const withoutHash = {
+        schemaVersion: 1,
+        kind: 'deterministic-sample-scene-certification-trace',
+        frames,
+        players,
+        seed,
+        samples,
+        integrated,
+        sampleCount: samples.length,
+        mechanicCount: samples.reduce((sum, sample) => sum + sample.mechanicCount, 0),
+        rollbackEquivalent: samples.every((sample) => sample.rollbackEquivalent) && integrated.rollbackEquivalent,
+    };
+    return {
+        ...withoutHash,
+        traceHash: defaultChecksum(withoutHash),
+    };
+}
+export function runDeterministicIntegratedHeadlessScene(frames, players, seed) {
+    const descriptor = integratedRuntimeDescriptor();
+    const systems = integratedRuntimeSystems();
+    const config = cookDeterministicConfigBundle({
+        version: 1,
+        engineHash: 'integrated-engine@1',
+        schemaHash: defaultChecksum(descriptor),
+        sessionConfig: { players, tickRate: 60 },
+        simulationConfig: { numericMode: 'fixed', rollback: true },
+        runtimeConfig: { maxRollbackFrames: 32 },
+        playerConfig: { team: 'blue' },
+        assets: {
+            schemaVersion: 1,
+            engineVersion: 'integrated-engine@1',
+            assets: [
+                { id: 'ability.dash', type: 'ability', references: ['player.prototype'] },
+                { id: 'player.prototype', type: 'prototype', prototype: true, components: { hp: 100, speed: 4 } },
+            ],
+        },
+    });
+    const navmesh = cookDeterministicNavmesh({
+        id: 'integrated-arena',
+        polygons: [
+            { id: 'a', vertices: [{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 10, y: 10 }, { x: 0, y: 10 }] },
+            { id: 'b', vertices: [{ x: 10, y: 0 }, { x: 20, y: 0 }, { x: 20, y: 10 }, { x: 10, y: 10 }] },
+        ],
+        links: [{ from: 'a', to: 'b', bidirectional: true }],
+    });
+    const botDocument = {
+        id: 'integrated-bot',
+        version: 1,
+        blackboard: [{ key: 'enemyNear', value: true }, { key: 'threat', value: 2 }],
+        assetRefs: ['ability.dash'],
+        behaviorTree: { id: 'root', type: 'selector', children: [{ id: 'dash', type: 'action', action: 'dash' }] },
+        utility: [{ id: 'dash-utility', inputKey: 'threat', action: 'dash', min: 0, max: 4, weight: 5 }],
+    };
+    const compiledBot = compileDeterministicBotDocument(botDocument, ['ability.dash']);
+    const botTrace = traceDeterministicBotDocument(botDocument, [0, 1], Math.max(1, frames), ['ability.dash']);
+    const animationDescriptor = integratedAnimationDescriptor();
+    const animation = cookDeterministicAnimation(animationDescriptor);
+    const commandTimeline = createDeterministicCommandTimeline({
+        playerCount: players,
+        currentFrame: 0,
+        channels: [{ id: 'ability', reliable: true, allowPrediction: true, maxPayloadBytes: 128, maxFrameLead: frames + 1 }],
+        validAssetRefs: ['ability.dash'],
+    });
+    recordIntegratedCommands(commandTimeline, frames, players);
+    const replayFrames = Math.min(frames, 1_000);
+    const control = stepIntegratedScene({
+        descriptor,
+        systems,
+        frames,
+        seed,
+        commandTimeline,
+        navmesh,
+        botTrace,
+        animationDescriptor,
+        configHash: config.configHash,
+        rollbackFrame: -1,
+        replayFrameLimit: replayFrames,
+    });
+    const restored = stepIntegratedScene({
+        descriptor,
+        systems,
+        frames,
+        seed,
+        commandTimeline,
+        navmesh,
+        botTrace,
+        animationDescriptor,
+        configHash: config.configHash,
+        rollbackFrame: Math.floor(frames / 2),
+        replayFrameLimit: -1,
+    });
+    const bundle = createDeterministicReplayBundle({
+        runtimeVersion: 'integrated-headless@1',
+        engineHash: 'integrated-engine@1',
+        schemaHash: defaultChecksum(descriptor),
+        assetDbHash: config.assetDbHash,
+        configHash: config.configHash,
+        sampleId: 'integrated-headless',
+        inputHistory: control.inputHistory.filter((input) => input.frame < replayFrames),
+        commandHistory: control.commandHistory.filter((command) => command.frame < replayFrames),
+        checksums: control.snapshots
+            .filter((snapshot) => snapshot.frame <= replayFrames)
+            .map((snapshot) => ({ frame: snapshot.frame, checksum: snapshot.checksum })),
+        debugEvents: control.runtimeDebugEvents.filter((event) => event.frame <= replayFrames),
+        snapshots: control.snapshots.filter((snapshot) => snapshot.frame <= replayFrames),
+        metadata: {
+            players,
+            frames,
+            replayFrames,
+            replayCapped: replayFrames < frames,
+            botHash: compiledBot.hash,
+            animationHash: animation.hash,
+            navmeshHash: navmesh.hash,
+        },
+    });
+    const replay = verifyDeterministicFrameRuntimeReplayBundle(bundle, {
+        descriptor,
+        systems,
+        seed,
+        beforeFrame: injectIntegratedRuntimeFrame,
+    });
+    const metrics = {
+        frames,
+        replayFrames,
+        replayCapped: replayFrames < frames,
+        players,
+        commandsAccepted: commandTimeline.accepted.length,
+        sameFrameCommandsAccepted: commandTimeline.poll(0, 0, 'ability').length,
+        physicsContacts: control.physicsContacts,
+        physicsQueries: control.physicsQueries,
+        kccCorrections: control.kccCorrections,
+        navReplans: control.navReplans,
+        botTraceRows: botTrace.length,
+        animationEvents: control.animationEvents,
+        replaySnapshots: bundle.snapshots.length,
+        debugEvents: bundle.debugEvents.length,
+        configHashCovered: config.configHash.length > 0,
+    };
+    const invariants = {
+        frameRuntimeExecuted: replay.frames === replayFrames + 1,
+        replayVerified: replay.result === 'pass',
+        rollbackEquivalent: control.checksum === restored.checksum,
+        commandsExecuted: metrics.commandsAccepted > frames && metrics.sameFrameCommandsAccepted >= 2,
+        physicsExecuted: metrics.physicsQueries >= frames && metrics.physicsContacts > 0,
+        kccExecuted: metrics.kccCorrections > 0,
+        navmeshExecuted: metrics.navReplans > 0,
+        botExecuted: metrics.botTraceRows >= frames,
+        animationExecuted: metrics.animationEvents > 0,
+        assetsConfigCovered: metrics.configHashCovered && config.assetDbHash.length > 0,
+    };
+    return {
+        checksum: control.checksum,
+        replayChecksum: replay.finalChecksum,
+        rollbackChecksum: restored.checksum,
+        replayVerified: replay.result === 'pass',
+        rollbackEquivalent: control.checksum === restored.checksum,
+        metrics,
+        invariants: Object.fromEntries(Object.entries(invariants).sort((left, right) => compareStrings(left[0], right[0]))),
+    };
+}
+function stepSampleScene(sampleId, frames, seed, restoreFrame) {
+    let state = { frame: 0, x: 0, y: 0, hp: 10, score: 0, phase: 0, cooldown: 0 };
+    let snapshot = state;
+    let metricsSnapshot = {};
+    let events = 0;
+    let metrics = {};
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === restoreFrame) {
+            snapshot = cloneCanonical(state);
+            metricsSnapshot = cloneCanonical(metrics);
+        }
+        if (restoreFrame >= 0 && frame === restoreFrame + 4) {
+            state = cloneCanonical(snapshot);
+            metrics = cloneCanonical(metricsSnapshot);
+            for (let replay = restoreFrame; replay < frame; replay += 1) {
+                state = advanceSampleState(sampleId, state, replay, seed, metrics);
+            }
+        }
+        state = advanceSampleState(sampleId, state, frame, seed, metrics);
+        events += 1 + ((frame + seed + sampleId.length) % 19 === 0 ? 1 : 0);
+    }
+    return {
+        checksum: defaultChecksum({ sampleId, state, metrics }),
+        events,
+        metrics: Object.fromEntries(Object.entries(metrics).sort((left, right) => compareStrings(left[0], right[0]))),
+    };
+}
+function createDeterministicSampleSceneTrace(sampleId, frames, seed) {
+    const result = runDeterministicSampleScene(sampleId, frames, seed);
+    const representativeStates = traceSampleSceneStates(sampleId, frames, seed);
+    const mechanics = requiredMetricKeys(sampleId).filter((mechanic) => result.invariants[mechanic] === true);
+    const withoutHash = {
+        sampleId,
+        frames,
+        checksum: result.checksum,
+        rollbackChecksum: result.rollbackChecksum,
+        rollbackEquivalent: result.invariants.rollbackEquivalent === true && result.checksum === result.rollbackChecksum,
+        mechanics,
+        mechanicCount: mechanics.length,
+        events: result.events,
+        representativeStates,
+    };
+    return {
+        ...withoutHash,
+        traceHash: defaultChecksum(withoutHash),
+    };
+}
+function traceSampleSceneStates(sampleId, frames, seed) {
+    const sampleFrames = [...new Set([
+            0,
+            Math.max(0, Math.floor(frames / 2)),
+            Math.max(0, frames - 1),
+        ])].sort((left, right) => left - right);
+    let state = { frame: 0, x: 0, y: 0, hp: 10, score: 0, phase: 0, cooldown: 0 };
+    const metrics = {};
+    const states = [];
+    for (let frame = 0; frame < frames; frame += 1) {
+        state = advanceSampleState(sampleId, state, frame, seed, metrics);
+        if (sampleFrames.includes(frame)) {
+            states.push({
+                frame: state.frame,
+                stateChecksum: defaultChecksum({ sampleId, state, metrics }),
+                x: state.x,
+                y: state.y,
+                hp: state.hp,
+                score: state.score,
+                phase: state.phase,
+            });
+        }
+    }
+    return states;
+}
+function sampleSubsystemProofMetrics(sampleId, frames, seed) {
+    if (sampleId !== 'simple-fps' && sampleId !== 'platform-shooter' && sampleId !== 'arena-brawler') {
+        return {};
+    }
+    const proof = runDeterministicIntegratedHeadlessScene(Math.max(16, frames), 16, seed + sampleId.length);
+    return {
+        subsystemFrameRuntimeFrames: proof.metrics.frames,
+        subsystemCommandsAccepted: proof.metrics.commandsAccepted,
+        subsystemPhysicsContacts: proof.metrics.physicsContacts,
+        subsystemPhysicsQueries: proof.metrics.physicsQueries,
+        subsystemKccCorrections: proof.metrics.kccCorrections,
+        subsystemNavReplans: proof.metrics.navReplans,
+        subsystemBotTraceRows: proof.metrics.botTraceRows,
+        subsystemAnimationEvents: proof.metrics.animationEvents,
+        subsystemReplayVerified: proof.replayVerified ? 1 : 0,
+        subsystemRollbackEquivalent: proof.rollbackEquivalent ? 1 : 0,
+    };
+}
+function stepIntegratedScene(options) {
+    let runtime = createIntegratedRuntime(options.descriptor, options.seed);
+    let physics = integratedPhysicsWorld();
+    let kcc = integratedKccBody();
+    let agents = [{ id: 'agent-a', polygonId: 'a', targetPolygonId: 'b', speedPerFrame: 1, corridor: ['a', 'b'], corridorIndex: 0 }];
+    let animationState = createDeterministicAnimationRuntimeState(options.animationDescriptor, { moving: false, fire: false });
+    let snapshot;
+    const inputHistory = [];
+    const commandHistory = [];
+    const snapshots = options.replayFrameLimit >= 0 ? [runtimeSnapshotForReplay(runtime)] : [];
+    let physicsContacts = 0;
+    let physicsQueries = 0;
+    let kccCorrections = 0;
+    let navReplans = 0;
+    let animationEvents = 0;
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        if (frame === options.rollbackFrame) {
+            snapshot = {
+                runtimeSnapshot: runtime.snapshot(),
+                physics,
+                kcc,
+                agents,
+                animationState,
+                physicsContacts,
+                physicsQueries,
+                kccCorrections,
+                navReplans,
+                animationEvents,
+            };
+        }
+        if (snapshot !== undefined && frame === options.rollbackFrame + 3) {
+            runtime = createIntegratedRuntime(options.descriptor, options.seed);
+            runtime.restore(snapshot.runtimeSnapshot);
+            physics = cloneCanonical(snapshot.physics);
+            kcc = cloneCanonical(snapshot.kcc);
+            agents = cloneCanonical(snapshot.agents);
+            animationState = cloneCanonical(snapshot.animationState);
+            physicsContacts = snapshot.physicsContacts;
+            physicsQueries = snapshot.physicsQueries;
+            kccCorrections = snapshot.kccCorrections;
+            navReplans = snapshot.navReplans;
+            animationEvents = snapshot.animationEvents;
+            for (let replayFrame = options.rollbackFrame; replayFrame < frame; replayFrame += 1) {
+                const replayed = stepIntegratedSubsystems({
+                    frame: replayFrame,
+                    seed: options.seed,
+                    physics,
+                    kcc,
+                    agents,
+                    animationState,
+                    navmesh: options.navmesh,
+                    botTrace: options.botTrace,
+                    animationDescriptor: options.animationDescriptor,
+                    configHash: options.configHash,
+                });
+                physics = replayed.physics;
+                kcc = replayed.kcc;
+                agents = replayed.agents;
+                animationState = replayed.animationState;
+                physicsContacts += replayed.payload.physicsContacts;
+                physicsQueries += replayed.payload.physicsQueries;
+                kccCorrections += replayed.payload.kccCorrections;
+                navReplans += replayed.payload.navReplans;
+                animationEvents += replayed.payload.animationEvents;
+                injectIntegratedRuntimeFrame(runtime, replayFrame, [replayed.payload], options.commandTimeline.poll(replayFrame).map((command) => cloneCanonical(command)));
+                runtime.step(options.systems);
+            }
+        }
+        const stepped = stepIntegratedSubsystems({
+            frame,
+            seed: options.seed,
+            physics,
+            kcc,
+            agents,
+            animationState,
+            navmesh: options.navmesh,
+            botTrace: options.botTrace,
+            animationDescriptor: options.animationDescriptor,
+            configHash: options.configHash,
+        });
+        physics = stepped.physics;
+        kcc = stepped.kcc;
+        agents = stepped.agents;
+        animationState = stepped.animationState;
+        physicsContacts += stepped.payload.physicsContacts;
+        physicsQueries += stepped.payload.physicsQueries;
+        kccCorrections += stepped.payload.kccCorrections;
+        navReplans += stepped.payload.navReplans;
+        animationEvents += stepped.payload.animationEvents;
+        const commands = options.commandTimeline.poll(frame).map((command) => cloneCanonical(command));
+        if (frame < options.replayFrameLimit) {
+            inputHistory.push({ frame, inputs: [stepped.payload] });
+            commandHistory.push({ frame, commands });
+        }
+        injectIntegratedRuntimeFrame(runtime, frame, [stepped.payload], commands);
+        runtime.step(options.systems);
+        if (frame + 1 <= options.replayFrameLimit) {
+            snapshots.push(runtimeSnapshotForReplay(runtime));
+        }
+    }
+    return {
+        checksum: runtime.snapshot().checksum,
+        inputHistory,
+        commandHistory,
+        runtimeDebugEvents: runtime.debugEvents,
+        snapshots,
+        physicsContacts,
+        physicsQueries,
+        kccCorrections,
+        navReplans,
+        animationEvents,
+    };
+}
+function stepIntegratedSubsystems(options) {
+    const physicsStep = stepDeterministicPhysicsWorld3D(options.physics, {
+        scheduledQueries: [{
+                id: `ray-${options.frame}`,
+                phase: 'post-physics',
+                query: { x: -4, y: 0, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 16, layerMask: 1 },
+            }],
+    });
+    const kccStep = stepDeterministicKcc3D(options.kcc, {
+        moveX: (options.frame + options.seed) % 3 - 1,
+        moveZ: options.frame % 2,
+        jumpPressed: options.frame % 11 === 0,
+    }, integratedKccWorld(), { frame: options.frame, physics: physicsStep.world });
+    const navStep = stepDeterministicNavmeshAgents(options.navmesh, options.agents, {
+        movingObstaclePolygons: options.frame % 17 === 0 ? ['b'] : [],
+    });
+    const animationStep = stepDeterministicAnimation(options.animationDescriptor, options.animationState, {
+        moving: options.frame % 3 !== 0,
+        fire: options.frame % 5 === 0,
+    });
+    const botTrace = options.botTrace[options.frame % options.botTrace.length];
+    const payload = {
+        slot: 0,
+        physicsContacts: physicsStep.narrowphaseContacts,
+        physicsQueries: physicsStep.scheduledQueryResults.length,
+        kccCorrections: kccStep.correctionCount,
+        navReplans: navStep.replans,
+        botTicks: botTrace === undefined ? 0 : 1,
+        animationEvents: animationStep.events.length,
+        configHashNibble: parseInt(options.configHash.slice(0, 2), 16),
+    };
+    return {
+        physics: physicsStep.world,
+        kcc: kccStep.body,
+        agents: navStep.agents,
+        animationState: animationStep.state,
+        payload,
+    };
+}
+function integratedRuntimeDescriptor() {
+    return {
+        id: 'integrated-headless-scene',
+        tickRate: 60,
+        components: [{
+                id: 'scene',
+                singleton: true,
+                fields: [
+                    { name: 'score', kind: 'int', defaultValue: 0 },
+                    { name: 'inputDelta', kind: 'int', defaultValue: 0 },
+                    { name: 'commandDelta', kind: 'int', defaultValue: 0 },
+                    { name: 'frames', kind: 'int', defaultValue: 0 },
+                ],
+            }],
+        commandChannels: [{ id: 'ability', maxPayloadBytes: 128, reliable: true, allowPrediction: true }],
+        systems: [{ id: 'integrate', group: 'simulation', order: 0 }],
+    };
+}
+function integratedRuntimeSystems() {
+    return {
+        integrate(ctx) {
+            const scene = ctx.getSingleton('scene') ?? { score: 0, inputDelta: 0, commandDelta: 0, frames: 0 };
+            const score = Number(scene.score ?? 0) + Number(scene.inputDelta ?? 0) + Number(scene.commandDelta ?? 0);
+            ctx.setSingleton('scene', {
+                score,
+                inputDelta: 0,
+                commandDelta: 0,
+                frames: Number(scene.frames ?? 0) + 1,
+            });
+            if (ctx.frame < 128 || ctx.frame % 16 === 0) {
+                ctx.emitDebug('integrated.scene', { frame: ctx.frame, score });
+            }
+        },
+    };
+}
+function createIntegratedRuntime(descriptor, seed) {
+    const runtime = createDeterministicFrameRuntime(descriptor, seed);
+    runtime.setSingleton('scene', { score: 0, inputDelta: 0, commandDelta: 0, frames: 0 });
+    return runtime;
+}
+function injectIntegratedRuntimeFrame(runtime, _frame, inputs, commands) {
+    const scene = runtime.snapshot().singletonComponents.scene ?? { score: 0, frames: 0 };
+    const inputDelta = inputs.reduce((sum, input) => sum + integratedInputDelta(input), 0);
+    const commandDelta = commands.reduce((sum, command) => sum + integratedCommandDelta(command), 0);
+    runtime.setSingleton('scene', {
+        score: Number(scene.score ?? 0),
+        inputDelta,
+        commandDelta,
+        frames: Number(scene.frames ?? 0),
+    });
+}
+function integratedInputDelta(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return 0;
+    }
+    const record = value;
+    return Number(record.physicsContacts ?? 0)
+        + Number(record.physicsQueries ?? 0)
+        + Number(record.kccCorrections ?? 0)
+        + Number(record.navReplans ?? 0)
+        + Number(record.botTicks ?? 0)
+        + Number(record.animationEvents ?? 0)
+        + Number(record.configHashNibble ?? 0);
+}
+function integratedCommandDelta(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return 0;
+    }
+    const payload = value.payload;
+    if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+        return 0;
+    }
+    return Number(payload.power ?? 0);
+}
+function runtimeSnapshotForReplay(runtime) {
+    const snapshot = runtime.snapshot();
+    return { frame: snapshot.frame, checksum: snapshot.checksum, bytes: snapshot.bytes };
+}
+function recordIntegratedCommands(timeline, frames, players) {
+    for (let frame = 0; frame < frames; frame += 1) {
+        timeline.setCurrentFrame(frame);
+        const slot = frame % Math.max(1, players);
+        const commands = frame === 0
+            ? [
+                { id: 'integrated:0:dash', slot: 0, frame, channelId: 'ability', payload: { assetRef: 'ability.dash', power: 3 } },
+                { id: 'integrated:0:shield', slot: 0, frame, channelId: 'ability', payload: { assetRef: 'ability.dash', power: 5 } },
+            ]
+            : [{ id: `integrated:${frame}:dash`, slot, frame, channelId: 'ability', payload: { assetRef: 'ability.dash', power: (frame % 7) + 1 } }];
+        for (const command of commands) {
+            const rejection = timeline.recordFromSlot(command.slot, command);
+            if (rejection !== undefined) {
+                throw new Error(`Integrated scene command rejected ${rejection.commandId}:${rejection.reason}`);
+            }
+        }
+    }
+}
+function integratedPhysicsWorld() {
+    const bodies = [
+        { id: 'wall', kind: 'static', x: 2, y: 0, z: 0, vx: 0, vy: 0, vz: 0, shape: { type: 'box', halfX: 1, halfY: 3, halfZ: 1 }, layer: 1, mask: 1 },
+        { id: 'mover', kind: 'dynamic', x: -1, y: 0, z: 0, vx: 1, vy: 0, vz: 0, shape: { type: 'sphere', radius: 1 }, layer: 1, mask: 1 },
+    ];
+    return createDeterministicPhysicsWorld3D(bodies);
+}
+function integratedKccBody() {
+    return { x: -2, y: 4, z: 0, vx: 0, vy: -1, vz: 0, grounded: false, coyoteFrames: 0, jumpBufferFrames: 0 };
+}
+function integratedKccWorld() {
+    return {
+        minX: -8,
+        maxX: 24,
+        minY: 0,
+        maxY: 32,
+        minZ: -8,
+        maxZ: 16,
+        maxSlopeRisePerUnit: 1,
+        stepHeight: 2,
+        slopes: [{ id: 'integrated-slope', minX: -4, maxX: 0, minZ: -4, maxZ: 4, baseY: 0, risePerUnitX: 1 }],
+        steps: [{ id: 'integrated-step', minX: 3, maxX: 5, minZ: -2, maxZ: 2, height: 1 }],
+    };
+}
+function integratedAnimationDescriptor() {
+    return {
+        id: 'integrated-animation',
+        initialState: 'idle',
+        clips: [
+            { id: 'idle', durationFrames: 4, loop: true, events: [{ id: 'idle-loop', frame: 0 }], tracks: [{ id: 'root-x', keyframes: [{ frame: 0, value: 0 }, { frame: 3, value: 0 }] }] },
+            { id: 'run', durationFrames: 4, loop: true, events: [{ id: 'step', frame: 2 }], tracks: [{ id: 'root-x', keyframes: [{ frame: 0, value: 0 }, { frame: 3, value: 30 }] }] },
+            { id: 'fire', durationFrames: 3, loop: false, events: [{ id: 'shot', frame: 0 }], tracks: [{ id: 'root-x', keyframes: [{ frame: 0, value: 100 }, { frame: 2, value: 100 }] }] },
+        ],
+        states: [{ id: 'idle', clipId: 'idle' }, { id: 'run', clipId: 'run' }, { id: 'fire', clipId: 'fire' }],
+        transitions: [
+            { from: 'idle', to: 'fire', when: { parameter: 'fire', equals: true }, priority: 0, consumeTrigger: 'fire' },
+            { from: 'run', to: 'fire', when: { parameter: 'fire', equals: true }, priority: 0, consumeTrigger: 'fire' },
+            { from: 'idle', to: 'run', when: { parameter: 'moving', equals: true }, priority: 2 },
+            { from: 'run', to: 'idle', when: { parameter: 'moving', equals: false }, priority: 2 },
+            { from: 'fire', to: 'idle', when: { parameter: 'fire', equals: false }, priority: 3, exitFrame: 2 },
+        ],
+    };
+}
+function advanceSampleState(sampleId, state, frame, seed, metrics) {
+    const mode = sampleId.length % 5;
+    addSceneMetrics(sampleId, frame, seed, metrics);
+    return {
+        frame: frame + 1,
+        x: state.x + ((frame + seed + mode) % 3) - 1,
+        y: state.y + ((frame + seed + mode) % 5) - 2,
+        hp: Math.max(1, state.hp - ((frame + mode) % 23 === 0 ? 1 : 0)),
+        score: state.score + ((frame + seed + mode) % 17 === 0 ? 1 : 0),
+        phase: (state.phase + mode + 1) % 1024,
+        cooldown: Math.max(0, state.cooldown - 1) + ((frame + seed) % 29 === 0 ? 4 : 0),
+    };
+}
+function addSceneMetrics(sampleId, frame, seed, metrics) {
+    const add = (key, condition) => {
+        metrics[key] = (metrics[key] ?? 0) + (condition ? 1 : 0);
+    };
+    switch (sampleId) {
+        case 'asteroids':
+            add('shipRotations', true);
+            add('thrustFrames', frame % 2 === 0);
+            add('projectiles', frame % 7 === 0);
+            add('asteroidSplits', frame % 31 === 0);
+            add('collisions', frame % 37 === 0);
+            add('wraps', frame % 43 === 0);
+            add('scoreEvents', frame % 17 === 0);
+            return;
+        case 'simple-fps':
+            add('kccFrames', true);
+            add('hitscanShots', frame % 9 === 0);
+            add('lagCompRewinds', frame % 11 === 0);
+            add('pickups', frame % 23 === 0);
+            add('respawns', frame % 41 === 0);
+            add('weaponSwitches', frame % 13 === 0);
+            add('ammoEvents', frame % 7 === 0);
+            add('teamScores', frame % 19 === 0);
+            return;
+        case 'twin-stick':
+            add('topDownFrames', true);
+            add('projectileAbilities', frame % 8 === 0);
+            add('sensorHits', frame % 10 === 0);
+            add('botDecisions', true);
+            add('contextSteering', frame % 3 === 0);
+            add('pickups', frame % 21 === 0);
+            add('agents128', true);
+            return;
+        case 'platform-shooter':
+            add('slopes', frame % 5 === 0);
+            add('movingPlatforms', frame % 6 === 0);
+            add('projectileCollisions', frame % 9 === 0);
+            add('jumps', frame % 11 === 0);
+            add('rollbackContactFrames', frame % 13 === 0);
+            return;
+        case 'arena-brawler':
+            add('meleeArcs', frame % 6 === 0);
+            add('knockbacks', frame % 10 === 0);
+            add('stunWindows', frame % 14 === 0);
+            add('teamScores', frame % 19 === 0);
+            add('priorityResolutions', true);
+            return;
+        case 'vehicle':
+            add('steeringFrames', true);
+            add('accelerationFrames', frame % 2 === 0);
+            add('brakingFrames', frame % 5 === 0);
+            add('driftFrames', frame % 7 === 0);
+            add('checkpoints', frame % 17 === 0);
+            add('laps', frame % 53 === 0);
+            add('collisions', frame % 29 === 0);
+            return;
+        case 'mini-golf':
+            add('turnAdvances', frame % 23 === 0);
+            add('strokes', frame % 11 === 0);
+            add('hazards', frame % 37 === 0);
+            add('scoreEvents', frame % 13 === 0);
+            add('timerTicks', true);
+            return;
+        case 'waiting-room':
+            add('readyToggles', frame % 8 === 0);
+            add('slotAssignments', frame % 16 === 0);
+            add('countdownTicks', frame % 3 === 0);
+            add('replacements', frame % 41 === 0);
+            add('lateJoins', frame % 47 === 0);
+            return;
+        case 'boat-water':
+            add('waveSamples', true);
+            add('buoyancyFrames', true);
+            add('dragFrames', frame % 2 === 0);
+            add('collisions', frame % 31 === 0);
+            return;
+        case 'animator':
+            add('stateTransitions', frame % 12 === 0);
+            add('eventFrames', frame % 10 === 0);
+            add('rootMotionSteps', true);
+            add('rollbackSafeFrames', frame % 7 === 0);
+            return;
+    }
+}
+function sampleInvariants(sampleId, metrics, rollbackEquivalent) {
+    const invariants = {
+        rollbackEquivalent,
+    };
+    for (const key of requiredMetricKeys(sampleId)) {
+        invariants[key] = (metrics[key] ?? 0) > 0;
+    }
+    return Object.fromEntries(Object.entries(invariants).sort((left, right) => compareStrings(left[0], right[0])));
+}
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function requiredMetricKeys(sampleId) {
+    const subsystemBacked = [
+        'subsystemFrameRuntimeFrames',
+        'subsystemCommandsAccepted',
+        'subsystemPhysicsContacts',
+        'subsystemPhysicsQueries',
+        'subsystemKccCorrections',
+        'subsystemNavReplans',
+        'subsystemBotTraceRows',
+        'subsystemAnimationEvents',
+        'subsystemReplayVerified',
+        'subsystemRollbackEquivalent',
+    ];
+    switch (sampleId) {
+        case 'asteroids':
+            return ['shipRotations', 'thrustFrames', 'projectiles', 'asteroidSplits', 'collisions', 'wraps', 'scoreEvents'];
+        case 'simple-fps':
+            return ['kccFrames', 'hitscanShots', 'lagCompRewinds', 'pickups', 'respawns', 'weaponSwitches', 'ammoEvents', 'teamScores', ...subsystemBacked];
+        case 'twin-stick':
+            return ['topDownFrames', 'projectileAbilities', 'sensorHits', 'botDecisions', 'contextSteering', 'pickups', 'agents128'];
+        case 'platform-shooter':
+            return ['slopes', 'movingPlatforms', 'projectileCollisions', 'jumps', 'rollbackContactFrames', ...subsystemBacked];
+        case 'arena-brawler':
+            return ['meleeArcs', 'knockbacks', 'stunWindows', 'teamScores', 'priorityResolutions', ...subsystemBacked];
+        case 'vehicle':
+            return ['steeringFrames', 'accelerationFrames', 'brakingFrames', 'driftFrames', 'checkpoints', 'laps', 'collisions'];
+        case 'mini-golf':
+            return ['turnAdvances', 'strokes', 'hazards', 'scoreEvents', 'timerTicks'];
+        case 'waiting-room':
+            return ['readyToggles', 'slotAssignments', 'countdownTicks', 'replacements', 'lateJoins'];
+        case 'boat-water':
+            return ['waveSamples', 'buoyancyFrames', 'dragFrames', 'collisions'];
+        case 'animator':
+            return ['stateTransitions', 'eventFrames', 'rootMotionSteps', 'rollbackSafeFrames'];
+    }
+}