@jgengine/core 0.19.0 → 0.22.0

package/dist/runtime/gameContext.js

@@ -1,3 +1,4 @@
+import { createAuthoredSimulation } from "../world/authoredSimulation.js";
 import { createCommandRegistry } from "../commands/commandRegistry.js";
 import {} from "../game/cosmetics.js";
 import { groundFieldFor } from "../world/terrain.js";
@@ -12,6 +13,7 @@ import { createItemUse } from "../item/use.js";
 import { createWeaponStats } from "../item/weapon.js";
 import {} from "../scene/entityStats.js";
 import {} from "../scene/entityStore.js";
+import { installPursuitPersistence } from "../scene/behaviorRuntime.js";
 import { createChangeSignal, notifyAfter } from "../store/changeSignal.js";
 import { createObservableKeyedStore } from "../store/observableKeyedStore.js";
 import { applyWorldSnapshot, composeWorldSnapshot, } from "./worldSnapshot.js";
@@ -22,7 +24,7 @@ import { localSaveBackend, memorySaveBackend } from "../game/saveStore.js";
 import { createSimClock } from "../time/simClock.js";
 import { createSimContext } from "./simContext.js";
 import { seededRng } from "../random/rng.js";
-import { createCameraDirector } from "./cameraDirector.js";
+import { createCameraDirector, installCameraPersistence } from "./cameraDirector.js";
 import { createParticleDirector } from "../vfx/particleDirector.js";
 import { createInputSnapshot } from "./inputSnapshot.js";
 import { baselineDescriptors } from "./descriptors/baseline.js";
@@ -62,6 +64,7 @@ export function createGameContext(options) {
         content,
         signalNotify: signal.notify,
         ground,
+        solids,
         events,
         time,
         ...(occluder !== undefined ? { occluder } : {}),
@@ -195,12 +198,26 @@ export function createGameContext(options) {
     // --- Combat installer (effects, projectiles, death, combat FX) ---
     // Command runner closes over `ctx` once assembled (same late-bind pattern as before).
     let ctxRef = null;
+    const { sweep, acceleration, targets, ...projectileBudgets } = definition.projectileTravel ?? {};
+    function projectileContext() {
+        if (ctxRef === null)
+            throw new Error("Projectile providers require an assembled GameContext");
+        return ctxRef;
+    }
     const combat = createCombatSubsystem({
         content,
         signalNotify: signal.notify,
         now,
         events,
         time,
+        projectileTravel: {
+            ...projectileBudgets,
+            ...(sweep === undefined ? {} : { sweep: (from, to, step) => sweep(projectileContext(), from, to, step) }),
+            ...(targets === undefined ? {} : { targets: () => targets(projectileContext()) }),
+            acceleration: acceleration === undefined
+                ? (position, _velocity, at, input) => authoredEnvironment.accelerationAt(position, at, input.travel?.windResponse ?? 0, input.travel?.maxAcceleration ?? 0, input.travel?.forceMask ?? 0)
+                : (position, velocity, at, input) => acceleration(projectileContext(), position, velocity, at, input),
+        },
         entities,
         objects,
         combatSpatial,
@@ -214,12 +231,16 @@ export function createGameContext(options) {
         lootRegistry,
         spawnWorldItem,
         despawnEntity,
-        runCommand(name, args) {
+        runCommand(name, args, actorUserId) {
             if (ctxRef === null)
                 return;
-            commandRegistry.run(ctxRef, name, args);
+            if (actorUserId === undefined)
+                ctxRef.game.commands.run(name, args);
+            else
+                ctxRef.game.commands.runAs(actorUserId, name, args);
         },
-        localUserId: player.userId,
+        userIdOf: (instanceId) => instanceId === player.userId || featureValue("players")?.has(instanceId)
+            ? instanceId : possession.ownerOf(instanceId),
         rng,
         ...(definition.physics !== undefined ? { physics: definition.physics } : {}),
     });
@@ -227,8 +248,9 @@ export function createGameContext(options) {
     const { projectiles, combatFx, vfxInstances, effects } = combat;
     const store = notifyAfter(createObservableKeyedStore(), ["set", "delete", "hydrate"], signal.notify);
     const { pile, loop, raceState, cardPiles, turnLoops } = createContextRegistries(signal.notify);
-    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic", "setChaseTuning"], signal.notify);
+    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic", "setChaseTuning", "setRig", "restore", "reset"], signal.notify);
     const particles = createParticleDirector();
+    const authoredEnvironment = createAuthoredSimulation({ document: definition.authoredDocument, timeSeconds: time.now, particles });
     const input = createInputSnapshot();
     // --- Descriptor install (single feature enable path) ---
     const featureDeps = {
@@ -246,6 +268,7 @@ export function createGameContext(options) {
         walletOf,
         setWallet: (userId, state) => wallets.set(userId, state),
         layouts,
+        itemTraits: playerSys.itemTraits,
         inventoryFor,
         ensureInstanceStats,
         seedUserPool,
@@ -342,6 +365,20 @@ export function createGameContext(options) {
         });
         saveModules.push(module);
     }
+    function reviveRestoredEntities(snapshot) {
+        if (!Object.hasOwn(snapshot, "entities") || !Array.isArray(snapshot["entities"]))
+            return;
+        for (const entity of entities.list()) {
+            const receive = content.entityById?.(entity.name)?.receive;
+            const alive = Object.values(receive ?? {}).every((rule) => {
+                const terminal = rule.order[rule.order.length - 1];
+                const pool = terminal === undefined ? undefined : statsByInstance.get(entity.id)?.[terminal];
+                return pool === undefined || pool.current > pool.min;
+            });
+            if (alive)
+                combat.death.revive(entity.id);
+        }
+    }
     // --- Assemble public GameContext ---
     const ctx = {
         rng,
@@ -352,11 +389,13 @@ export function createGameContext(options) {
                 despawn: despawnEntity,
                 update: entities.update,
                 setPose: entities.setPose,
+                setVelocity: entities.setVelocity,
                 setPoseConstraint: entities.setPoseConstraint,
                 get: entities.get,
                 list: entities.list,
                 ids: entities.ids,
                 subscribeMembership: entities.subscribeMembership,
+                subscribeBehaviors: entities.subscribeBehaviors,
                 spawnPoseOf: entities.spawnPoseOf,
                 resetToSpawn: entities.resetToSpawn,
                 resetAllToSpawn,
@@ -376,6 +415,9 @@ export function createGameContext(options) {
                 willHitProjectile: projectiles.willHitProjectile,
                 fireProjectile: projectiles.fireProjectile,
                 settleProjectile: projectiles.settleProjectile,
+                activeProjectiles: projectiles.activeProjectiles,
+                projectileState: projectiles.snapshot,
+                restoreProjectiles: projectiles.restore,
                 distance: spatial.distance,
                 inRadius: spatial.inRadius,
                 hasLineOfSight: spatial.hasLineOfSight,
@@ -409,6 +451,7 @@ export function createGameContext(options) {
             raycast: (input) => sceneRaycast.raycast(input),
             raycastAll: (input) => sceneRaycast.raycastAll(input),
         },
+        environment: authoredEnvironment,
         world: {
             ground,
             groundHeightAt: ground.sampleHeight,
@@ -507,7 +550,7 @@ export function createGameContext(options) {
             weapon,
         },
         time,
-        sim: createSimContext({ config: definition.simulation, entities }),
+        sim: createSimContext({ config: definition.simulation, entities, time }),
         camera,
         particles,
         input,
@@ -517,24 +560,46 @@ export function createGameContext(options) {
         snapshot: (viewer) => composeWorldSnapshot(replicationModules, viewer),
         hydrate(snapshot) {
             applyWorldSnapshot(replicationModules, snapshot);
+            reviveRestoredEntities(snapshot);
+            signal.notify();
+        },
+        state: () => structuredClone(composeWorldSnapshot(saveModules)),
+        restore(state) {
+            applyWorldSnapshot(saveModules, structuredClone(state));
+            reviveRestoredEntities(state);
             signal.notify();
         },
         replicationVersion,
         replicatesPerViewer: () => projectsViewers,
     };
     ctxRef = ctx;
+    ctx.sim.addStage({ id: "authored-environment", phase: "afterTick", run: (_dt, _tick, gameDt) => authoredEnvironment.step(gameDt) });
+    ctx.sim.addStage({ id: "projectile-targets", phase: "beforeMovement", run: (_dt, _tick, gameDt) => combat.captureProjectileTargets(gameDt) });
+    ctx.sim.addStage({ id: "projectile-travel", phase: "afterTick", run: (_dt, _tick, gameDt) => projectiles.advanceProjectiles(gameDt, time.now()) });
+    registerSave({ key: "environment", snapshot: authoredEnvironment.snapshot, hydrate: (state) => authoredEnvironment.restore(state) });
+    registerSave({ key: "projectiles", snapshot: projectiles.snapshot, hydrate: (state) => projectiles.restore(state) });
+    registerSave({
+        key: "sim",
+        snapshot: () => ctx.sim.snapshot(),
+        hydrate: (state) => ctx.sim.restore(state),
+        decode: (raw) => {
+            if (raw === null || typeof raw !== "object" || !("loop" in raw) || !("poses" in raw))
+                return null;
+            return raw;
+        },
+    });
     const physicsBackend = definition.physics?.backend;
     if (physicsBackend !== undefined) {
-        ctx.sim.addStage({ id: "physics", phase: "afterMovement", run: (dt) => physicsBackend.step(dt) });
+        ctx.sim.addStage({ id: "physics", phase: "afterMovement", run: (_dt, _tick, gameDt) => { if (gameDt > 0)
+                physicsBackend.step(gameDt); } });
     }
+    installPursuitPersistence(ctx, aoiRadius, definition.pursuit?.eligible);
+    installCameraPersistence(ctx);
     const saveOptions = resolveSaveOptions(definition, options);
     if (saveOptions !== undefined) {
         const saveTarget = {
-            snapshot: () => composeWorldSnapshot(saveModules),
-            hydrate: (snapshot) => {
-                applyWorldSnapshot(saveModules, snapshot);
-                signal.notify();
-            },
+            snapshot: ctx.state,
+            hydrate: ctx.restore,
             subscribe: signal.subscribe,
         };
         ctx.game.save = createRuntimeSave({ target: saveTarget, ...saveOptions });
@@ -561,10 +626,11 @@ function resolveSaveOptions(definition, options) {
         return undefined;
     const config = persist === undefined || persist === true ? {} : persist;
     return {
-        backend: config.storage === "memory" ? memorySaveBackend() : localSaveBackend(),
+        backend: config.storage === "memory" ? memorySaveBackend() : localSaveBackend(undefined, { errorMode: "throw" }),
         mode: config.mode,
         key: saveKey(definition.name),
         version: config.version,
+        migrate: config.migrate,
         autosaveMs: config.autosaveMs,
         now: options.now,
     };

package/dist/runtime/gameContextTypes.d.ts

@@ -1,3 +1,4 @@
+import type { AuthoredSimulationRuntime } from "../world/authoredSimulation.js";
 import type { Territory } from "../world/territory.js";
 import type { CurrencyDefinition } from "../economy/currency.js";
 import type { CardPile, CardPileConfig } from "../cards/cardPile.js";
@@ -257,11 +258,14 @@ export interface SceneEntityContext {
     despawn(instanceId: string): boolean;
     update: EntityStore["update"];
     setPose(instanceId: string, pose: EntityPose): boolean;
+    /** Set finite world velocity without changing pose; invalid tuples and missing entities return false unchanged. */
+    setVelocity: EntityStore["setVelocity"];
     setPoseConstraint: EntityStore["setPoseConstraint"];
     get(instanceId: string): SceneEntity | null;
     list(): readonly SceneEntity[];
     ids: EntityStore["ids"];
     subscribeMembership: EntityStore["subscribeMembership"];
+    subscribeBehaviors: EntityStore["subscribeBehaviors"];
     spawnPoseOf(instanceId: string): SpawnPose | null;
     resetToSpawn(instanceId: string): boolean;
     resetAllToSpawn(filter?: (entity: SceneEntity) => boolean): number;
@@ -287,6 +291,10 @@ export interface SceneEntityContext {
     willHitProjectile: ProjectileSystem["willHitProjectile"];
     fireProjectile: ProjectileSystem["fireProjectile"];
     settleProjectile: ProjectileSystem["settleProjectile"];
+    /** Live travel poses for game-owned arrow/projectile appearance. */
+    activeProjectiles: ProjectileSystem["activeProjectiles"];
+    projectileState: ProjectileSystem["snapshot"];
+    restoreProjectiles: ProjectileSystem["restore"];
     distance: SpatialApi["distance"];
     inRadius: SpatialApi["inRadius"];
     hasLineOfSight: SpatialApi["hasLineOfSight"];
@@ -458,6 +466,8 @@ export interface GameContext {
         raycastAll(input: SceneRaycastInput): readonly SceneRaycastHit[];
     };
     world: GameContextWorld;
+    /** Authored weather, shelter, accumulation and fire sampled from ctx.time. */
+    environment: AuthoredSimulationRuntime;
     /**
      * Deterministic `[0,1)` stream for this world — loot, AI, combat rolls, and any sim path that
      * needs randomness. Same seed → same sequence. Never fall back to `Math.random` in systems;
@@ -571,6 +581,10 @@ export interface GameContext {
     snapshot(viewer?: SnapshotViewer): WorldSnapshot;
     /** Apply a {@link WorldSnapshot} from an authoritative host, hydrating each subsystem key present in it. */
     hydrate(snapshot: WorldSnapshot): void;
+    /** Detached authoritative state, including save-only modules. Use for persistence, never client replication; available without `persist` or a save backend. */
+    state(): WorldSnapshot;
+    /** Restore authoritative state after initialization. Missing keys retain their initialized values, including in legacy replication-only saves. */
+    restore(state: WorldSnapshot): void;
     /** Aggregate world-dirty version summed across replicated modules; the host replicator skips an unchanged commit. @internal */
     replicationVersion(): number;
     /** True when a {@link GameContextOptions.replication} policy makes {@link snapshot} viewer-dependent (private/AOI projection is active). @internal */

package/dist/runtime/headlessRunner.d.ts

@@ -2,10 +2,12 @@ import type { GameDefinition, GameLoop } from "../game/defineGame.js";
 import type { PointerAxisState } from "../input/pointerAxis.js";
 import type { ModelAssetRef } from "../scene/assetCatalog.js";
 import { type GameContext, type GameContextContent, type GameContextModels } from "./gameContext.js";
-import type { InputSnapshot } from "./inputSnapshot.js";
+import type { InputFrame, InputSnapshot } from "./inputSnapshot.js";
 import { type SimSnapshot } from "./simSnapshot.js";
 /** One step's worth of player intent handed to {@link HeadlessRunner.step} — the held-action set and pointer state the shell would otherwise publish from the browser each frame. */
 export interface HeadlessInput {
+    /** Discrete presses on this recorded step, including taps released before its held-state sample. */
+    presses?: InputFrame["presses"];
     /** Replaces the held-action set for this step; edge detection (`justPressed`/`justReleased`) rolls the previous set forward. Omit to keep the last published set. */
     held?: readonly string[];
     /** Replaces the normalized pointer state; omit to leave the last pointer unchanged (pass `null` to clear it). */

package/dist/runtime/headlessRunner.js

@@ -18,15 +18,14 @@ export function createHeadlessRunner(options) {
     loop?.onNewPlayer?.(ctx);
     const simSnapshot = createContextSimSnapshot(ctx);
     const tuning = options.playerMovement === true
-        ? resolvePlayerMovementTuning({
-            physics: definition.physics,
-            world: definition.world,
-            movement: options.movement,
-        })
+        ? { ...resolvePlayerMovementTuning({
+                physics: definition.physics,
+                world: definition.world,
+                movement: options.movement,
+            }), authoritativeStep: true }
         : null;
     function publishInput(input) {
-        if (input.held !== undefined)
-            ctx.input.publish(input.held);
+        ctx.input.publish(input.held ?? ctx.input.held(), { pressed: input.presses?.map(press => press.action) ?? [] });
         if (input.pointer !== undefined)
             ctx.input.publishPointer(input.pointer);
     }
@@ -54,12 +53,12 @@ export function createHeadlessRunner(options) {
                 publishInput(input);
             const dt = Math.min(dtSeconds, maxStep);
             let total = 0;
-            ctx.sim.advance(dt, (stepDt) => {
-                const gameDt = ctx.time.advance(stepDt);
+            ctx.sim.advance(dt, (stepDt, _tick, gameDt) => {
+                ctx.input.beginStep();
                 total += gameDt;
                 ctx.sim.runStages("beforeMovement", stepDt);
-                if (tuning !== null) {
-                    stepPlayerMovement(ctx, player.userId, { held: ctx.input.held(), pointer: ctx.input.pointer() }, stepDt, tuning, options.heading, options.pitch);
+                if (tuning !== null && gameDt > 0) {
+                    stepPlayerMovement(ctx, player.userId, { held: ctx.input.held(), pointer: ctx.input.pointer() }, gameDt, tuning, options.heading, options.pitch);
                 }
                 ctx.sim.runStages("afterMovement", stepDt);
                 loop?.onTick?.(ctx, gameDt);
@@ -71,6 +70,7 @@ export function createHeadlessRunner(options) {
         snapshot: () => simSnapshot.capture(),
         restore(snapshot) {
             simSnapshot.restore(snapshot);
+            ctx.input.publish([], { reset: true });
         },
         tick: () => ctx.sim.tick(),
     };

package/dist/runtime/hostedGameRunner.d.ts

@@ -21,8 +21,17 @@ export interface HostedGameRunnerOptions<TAssetRef extends ModelAssetRef, TMulti
      * snapshot overlays the world state it seeded. Omit for a long-lived stateful host (ws) that keeps one runner.
      */
     restore?: WorldSnapshot;
+    /** Persisted replication cursor; restored hosts continue above it. */
+    revision?: number;
     /** Render-model lookup for collider auto-fit — pass the same lookup the shell derives from `entityModels`/`objectModels` so host and clients resolve identical hitboxes. */
     models?: GameContextModels;
+    /** Process-local reconnect protection. Departed admission marks expire after 5 minutes or the oldest is evicted above 256 users; zero disables retention. Live members and staged replay ticks are never evicted. */
+    inputRetention?: {
+        maxDepartedUsers?: number;
+        departedTtlMs?: number;
+        /** Wall-clock milliseconds; injectable for deterministic hosts and tests. */
+        nowMs?: () => number;
+    };
 }
 /**
  * The GameContext-loop equivalent of the pure-reducer `createGameHost`: one authoritative `createGameContext`
@@ -36,8 +45,18 @@ export interface HostedGameRunner {
     /** Re-attach an already-joined member on a reconstructed runner — restores membership and `ctx.game.players` without re-firing `onNewPlayer`. Stateless hosts call it once per persisted member after `restore`. */
     resume(userId: string): void;
     leave(userId: string): void;
-    /** Record a client's latest input frame — stashed for {@link heldInput} and mirrored onto `ctx.game.players` so the movement seam reads each player's intent in `onTick`. */
+    /** Record a joined/resumed client's latest input frame; nonmember input is ignored. Stashed for {@link heldInput} and sampled onto `ctx.game.players` in `onTick`. */
     input(userId: string, frame: InputFrame): void;
+    /** Counts actual retained input storage for host health checks; elapsed recorder history is excluded and staged future replay ticks remain. */
+    inputStats(): {
+        members: number;
+        recorders: number;
+        recordedFrames: number;
+        latestInputs: number;
+        wireSequences: number;
+        pressSequences: number;
+        departedUsers: number;
+    };
     heldInput(userId: string): InputFrame | null;
     command(userId: string, name: string, input: unknown): CommandResult<GameContext>;
     tick(dt: number): number;
@@ -45,6 +64,10 @@ export interface HostedGameRunner {
     revision(): number;
     /** The full world baseline — projected to only what `viewer` may see when the context carries a replication policy, else the whole world. */
     snapshot(viewer?: SnapshotViewer): WorldSnapshot;
+    /** Complete detached authoritative state for persistence, including save-only modules. */
+    state(): WorldSnapshot;
+    /** Commit replication without advancing simulation or running game ticks. */
+    commit(): number;
     /** True when {@link snapshot} is viewer-dependent (a replication policy projects private/AOI state); a host must then serve each viewer its own frame. */
     projectsViewers(): boolean;
     members(): readonly string[];

package/dist/runtime/hostedGameRunner.js

@@ -24,29 +24,142 @@ export function createHostedGameRunner(options) {
     const loop = definition.loop ?? {};
     const replicator = createWorldReplicator(() => ctx.snapshot(), {
         worldVersion: () => ctx.replicationVersion(),
+        initialRevision: options.revision ?? 0,
     });
     const members = new Map();
     const inputs = new Map();
     const latestInputs = new Map();
-    const movementTuning = resolvePlayerMovementTuning({ world: definition.world, physics: definition.physics });
+    const movementTuning = { ...resolvePlayerMovementTuning({ world: definition.world, physics: definition.physics }), authoritativeStep: true };
     const inputSeq = new Map();
+    const inputPressSeq = new Map();
+    const departed = new Map();
+    const maxDepartedUsers = options.inputRetention?.maxDepartedUsers ?? 256;
+    const departedTtlMs = options.inputRetention?.departedTtlMs ?? 300_000;
+    const inputNowMs = options.inputRetention?.nowMs ?? Date.now;
+    if (!Number.isInteger(maxDepartedUsers) || maxDepartedUsers < 0 || !Number.isFinite(departedTtlMs) || departedTtlMs < 0) {
+        throw new RangeError("inputRetention requires a nonnegative integer user limit and finite nonnegative TTL");
+    }
+    let retentionTime = -Infinity;
+    const retentionNow = () => {
+        const time = inputNowMs();
+        if (!Number.isFinite(time))
+            throw new RangeError("inputRetention.nowMs must return finite milliseconds");
+        return retentionTime = Math.max(retentionTime, time);
+    };
+    const expireDeparted = () => {
+        const time = retentionNow();
+        // Monotone leave times keep insertion order equal to expiry order, even if
+        // the wall clock reverses. Live ingress inspects only the first tombstone.
+        while (departed.size > 0) {
+            const [userId, expiresAt] = departed.entries().next().value;
+            if (expiresAt > time && departed.size <= maxDepartedUsers)
+                break;
+            departed.delete(userId);
+            inputSeq.delete(userId);
+            inputPressSeq.delete(userId);
+        }
+    };
+    const compactRecorder = (recorder, tick) => {
+        const continuous = recorder.frameAt(tick);
+        const frames = recorder.frames().filter(entry => entry.tick > tick);
+        if (continuous !== null) {
+            const { presses: _consumed, ...held } = continuous;
+            frames.unshift({ tick, frame: held });
+        }
+        recorder.restore({ frames });
+    };
     let hostTick = 0;
+    const inputModule = {
+        key: "hostInput",
+        snapshot() {
+            const tick = ctx.sim.tick();
+            const saved = [];
+            for (const userId of members.keys()) {
+                const recorder = inputs.get(userId);
+                const latest = latestInputs.get(userId);
+                if (recorder === undefined || latest === undefined)
+                    continue;
+                const continuous = recorder.frameAt(tick);
+                // Keep continuous intent and unconsumed future ticks, never elapsed history.
+                // Live input coalesces onto the next tick; explicit replay may stage future ticks.
+                const frames = recorder.frames().filter(entry => entry.tick > tick);
+                if (continuous !== null) {
+                    const { presses: _consumed, ...held } = continuous;
+                    frames.unshift({ tick, frame: held });
+                }
+                const seq = inputSeq.get(userId);
+                const pressSeq = inputPressSeq.get(userId);
+                saved.push({ userId, latest, recorder: { frames }, ...(seq === undefined ? {} : { seq }), ...(pressSeq === undefined ? {} : { pressSeq }) });
+            }
+            return saved;
+        },
+        hydrate(saved) {
+            inputs.clear();
+            latestInputs.clear();
+            inputSeq.clear();
+            inputPressSeq.clear();
+            departed.clear();
+            for (const input of saved) {
+                const recorder = createInputRecorder();
+                recorder.restore(input.recorder);
+                inputs.set(input.userId, recorder);
+                latestInputs.set(input.userId, input.latest);
+                if (input.seq !== undefined)
+                    inputSeq.set(input.userId, input.seq);
+                if (input.pressSeq !== undefined)
+                    inputPressSeq.set(input.userId, input.pressSeq);
+            }
+        },
+        decode(raw) {
+            const frame = (value) => {
+                if (value === null || typeof value !== "object" || !("held" in value) || !Array.isArray(value.held) || !value.held.every(action => typeof action === "string"))
+                    return false;
+                if (!("pointer" in value))
+                    return false;
+                const pointer = value.pointer;
+                if (pointer !== null && (typeof pointer !== "object" || !("x" in pointer) || !("y" in pointer) || !("active" in pointer) || !Number.isFinite(pointer.x) || !Number.isFinite(pointer.y) || typeof pointer.active !== "boolean"))
+                    return false;
+                if ("tick" in value && value.tick !== undefined && !Number.isFinite(value.tick))
+                    return false;
+                if ("presses" in value && value.presses !== undefined && (!Array.isArray(value.presses) || !value.presses.every(press => press !== null && typeof press === "object" && typeof press.action === "string" && Number.isFinite(press.seq))))
+                    return false;
+                if ("analog" in value && value.analog !== undefined && value.analog !== null && (typeof value.analog !== "object" || Array.isArray(value.analog) || !Object.values(value.analog).every(Number.isFinite)))
+                    return false;
+                return true;
+            };
+            if (!Array.isArray(raw) || !raw.every(input => input !== null && typeof input === "object" && typeof input.userId === "string" &&
+                (input.seq === undefined || Number.isFinite(input.seq)) && (input.pressSeq === undefined || Number.isFinite(input.pressSeq)) && frame(input.latest) &&
+                input.recorder !== null && typeof input.recorder === "object" && Array.isArray(input.recorder.frames) &&
+                input.recorder.frames.every((entry) => entry !== null && typeof entry === "object" && Number.isFinite(entry.tick) && frame(entry.frame))))
+                return null;
+            if (new Set(raw.map(input => input.userId)).size !== raw.length)
+                return null;
+            return raw;
+        },
+    };
+    ctx.game.registerSave?.(inputModule);
     loop.onInit?.(ctx);
     syncLifecyclePhase(ctx, definition.lifecycle);
     if (restore !== undefined)
-        ctx.hydrate(restore);
+        ctx.restore(restore);
     return {
         join(userId, isNew) {
+            expireDeparted();
             if (members.has(userId))
                 return;
+            departed.delete(userId);
             const player = { userId, isNew };
             members.set(userId, player);
+            ctx.player.possession.own(userId, userId);
             ctx.game.players?.join(userId, isNew);
             loop.onNewPlayer?.(ctx, player);
             syncLifecyclePhase(ctx, definition.lifecycle);
         },
         resume(userId) {
+            expireDeparted();
+            departed.delete(userId);
             members.set(userId, { userId, isNew: false });
+            ctx.player.possession.own(userId, userId);
             ctx.game.players?.join(userId, false);
         },
         leave(userId) {
@@ -56,12 +169,22 @@ export function createHostedGameRunner(options) {
             members.delete(userId);
             inputs.delete(userId);
             latestInputs.delete(userId);
-            inputSeq.delete(userId);
+            // Retain only bounded, recent admission marks; departed ingress is ignored.
+            if (inputSeq.has(userId) || inputPressSeq.has(userId)) {
+                departed.delete(userId);
+                departed.set(userId, retentionNow() + departedTtlMs);
+            }
+            expireDeparted();
             loop.onPlayerLeave?.(ctx, player);
             ctx.game.players?.leave(userId);
         },
         input(userId, frame) {
+            expireDeparted();
+            if (!members.has(userId))
+                return;
             const seq = frame.seq;
+            if ((seq !== undefined && !Number.isFinite(seq)) || (frame.tick !== undefined && !Number.isFinite(frame.tick)))
+                return;
             if (seq !== undefined) {
                 const lastSeq = inputSeq.get(userId);
                 if (lastSeq !== undefined && seq <= lastSeq)
@@ -73,8 +196,26 @@ export function createHostedGameRunner(options) {
                 recorder = createInputRecorder();
                 inputs.set(userId, recorder);
             }
-            recorder.record(frame.tick ?? ctx.sim.tick() + 1, frame);
-            latestInputs.set(userId, frame);
+            let admitted = frame;
+            if (frame.presses !== undefined) {
+                let lastPress = inputPressSeq.get(userId) ?? -Infinity;
+                const presses = [...frame.presses].sort((a, b) => a.seq - b.seq).filter(press => {
+                    if (!Number.isFinite(press.seq) || press.seq <= lastPress)
+                        return false;
+                    lastPress = press.seq;
+                    return true;
+                });
+                if (presses.length > 0)
+                    inputPressSeq.set(userId, lastPress);
+                admitted = { ...frame, presses };
+            }
+            recorder.record(frame.tick ?? ctx.sim.tick() + 1, admitted);
+            compactRecorder(recorder, ctx.sim.tick());
+            latestInputs.set(userId, admitted);
+        },
+        inputStats() {
+            expireDeparted();
+            return { members: members.size, recorders: inputs.size, recordedFrames: [...inputs.values()].reduce((count, recorder) => count + recorder.frames().length, 0), latestInputs: latestInputs.size, wireSequences: inputSeq.size, pressSequences: inputPressSeq.size, departedUsers: departed.size };
         },
         heldInput(userId) {
             return latestInputs.get(userId) ?? null;
@@ -83,8 +224,9 @@ export function createHostedGameRunner(options) {
             return ctx.game.commands.runAs(userId, name, input);
         },
         tick(dt) {
+            expireDeparted();
             hostTick += 1;
-            ctx.sim.advance(dt, (stepDt, tick) => {
+            ctx.sim.advance(dt, (stepDt, tick, gameDt) => {
                 for (const [userId, recorder] of inputs) {
                     const frame = recorder.frameAt(tick);
                     if (frame !== null)
@@ -93,13 +235,15 @@ export function createHostedGameRunner(options) {
                 ctx.sim.runStages("beforeMovement", stepDt);
                 for (const userId of members.keys()) {
                     const frame = inputs.get(userId)?.frameAt(tick) ?? null;
-                    if (frame !== null)
-                        serverStep(ctx, userId, frame, stepDt, movementTuning);
+                    if (frame !== null && gameDt > 0)
+                        serverStep(ctx, userId, frame, gameDt, movementTuning);
                 }
                 ctx.sim.runStages("afterMovement", stepDt);
-                loop.onTick?.(ctx, stepDt);
-                advanceBehaviors(ctx, stepDt);
+                loop.onTick?.(ctx, gameDt);
+                advanceBehaviors(ctx, gameDt);
                 ctx.sim.runStages("afterTick", stepDt);
+                for (const recorder of inputs.values())
+                    compactRecorder(recorder, tick);
             });
             syncLifecyclePhase(ctx, definition.lifecycle);
             return replicator.commit();
@@ -107,6 +251,8 @@ export function createHostedGameRunner(options) {
         diff: (sinceRevision) => replicator.diff(sinceRevision),
         revision: () => replicator.revision(),
         snapshot: (viewer) => ctx.snapshot(viewer === undefined ? undefined : { ...viewer, tick: hostTick }),
+        state: ctx.state,
+        commit: () => replicator.commit(),
         projectsViewers: () => ctx.replicatesPerViewer(),
         members: () => Array.from(members.keys()),
         context: () => ctx,