@jgengine/core 0.18.1 → 0.21.0

package/dist/runtime/gameContext.js

@@ -1,6 +1,8 @@
+import { createAuthoredSimulation } from "../world/authoredSimulation.js";
 import { createCommandRegistry } from "../commands/commandRegistry.js";
 import {} from "../game/cosmetics.js";
 import { groundFieldFor } from "../world/terrain.js";
+import { createWorldSolids, structureSolids } from "../world/worldSolids.js";
 import { createGameEvents } from "../game/events.js";
 import { createGameFeed } from "../game/feed.js";
 import { setGamePhase } from "../game/gamePhase.js";
@@ -11,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";
@@ -21,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";
@@ -43,6 +46,10 @@ export function createGameContext(options) {
     const activeUserId = () => actingUserId ?? player.userId;
     const time = createSimClock({ config: definition.time, onChange: signal.notify });
     const ground = groundFieldFor(definition.world);
+    const solids = createWorldSolids();
+    if (definition.world?.kind === "environment") {
+        solids.set("environment:structures", structureSolids(definition.world, ground.sampleHeight));
+    }
     const rawEvents = createGameEvents();
     const events = {
         on: rawEvents.on,
@@ -57,6 +64,7 @@ export function createGameContext(options) {
         content,
         signalNotify: signal.notify,
         ground,
+        solids,
         events,
         time,
         ...(occluder !== undefined ? { occluder } : {}),
@@ -190,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,
@@ -209,20 +231,26 @@ 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 } : {}),
     });
     scene.setOnAfterSpawn((instanceId) => combat.death.revive(instanceId));
     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 = {
@@ -240,6 +268,7 @@ export function createGameContext(options) {
         walletOf,
         setWallet: (userId, state) => wallets.set(userId, state),
         layouts,
+        itemTraits: playerSys.itemTraits,
         inventoryFor,
         ensureInstanceStats,
         seedUserPool,
@@ -336,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,
@@ -346,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,
@@ -370,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,
@@ -403,9 +451,11 @@ export function createGameContext(options) {
             raycast: (input) => sceneRaycast.raycast(input),
             raycastAll: (input) => sceneRaycast.raycastAll(input),
         },
+        environment: authoredEnvironment,
         world: {
             ground,
             groundHeightAt: ground.sampleHeight,
+            solids,
         },
         game: {
             territory: options.territory,
@@ -500,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,
@@ -510,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 });
@@ -554,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";
@@ -11,6 +12,7 @@ import type { ChargeOptions as WalletChargeOptions } from "../economy/wallet.js"
 import type { Cosmetics } from "../game/cosmetics.js";
 import type { GameDefinition } from "../game/defineGame.js";
 import type { TerrainField } from "../world/terrain.js";
+import type { WorldSolids } from "../world/worldSolids.js";
 import type { GameEventMap, GameEvents, VfxKind } from "../game/events.js";
 import type { VfxInstanceStore } from "../game/vfxInstance.js";
 import type { GameFeed } from "../game/feed.js";
@@ -256,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;
@@ -286,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"];
@@ -344,6 +353,11 @@ export type WorldItemPickupResult = {
     status: "rejected";
     reason: string;
 };
+/**
+ * `ctx.scene.worldItem`: items lying in the world — spawn, list, find the nearest, and pick up into a player's bag.
+ *
+ * @capability world-item-pickup pick up dropped items: ctx.scene.worldItem nearestInRadius → pickup into the player's inventory
+ */
 export interface SceneWorldItemContext {
     spawn(input: WorldItemSpawnInput): WorldItemRecord;
     get(instanceId: string): WorldItemRecord | null;
@@ -390,6 +404,11 @@ export interface GameContextItemUse {
 export interface GameContextWorld {
     ground: TerrainField;
     groundHeightAt(x: number, z: number): number;
+    /**
+     * Static collision for world geometry that is not a scene object. `environment({ structures })`
+     * fills the `environment:structures` layer; `syncAuthoredSolids` fills one layer per studio object.
+     */
+    solids: WorldSolids;
 }
 export interface GameContextCards {
     /** Lazily creates (on first call, `config` required) or returns the existing notify-wrapped pile for `id`. */
@@ -420,14 +439,19 @@ export interface GameAudio {
     }): void;
     /**
      * Live-update retained loop `id` via `audio.loopSet`: `rate` re-pitches it (1 = authored pitch, clamped
-     * 0.25–4 by the shell), `gain` rescales volume (0–1), `at` repositions its emitter. Cheap to call every
-     * tick (~60 Hz) — the shell ramps rate/gain over ~20 ms to avoid zipper noise. A no-op when `id` is not a
-     * live loop (an update may race a stop) (#1051).
+     * 0.25–4 by the shell), `gain` rescales volume (0–1), `at` repositions its emitter. `lowpass`/`highpass`
+     * set filter cutoffs in Hz (muffle an engine off-throttle or behind a wall); `velocity` is the emitter's
+     * world velocity, which pitches the loop by doppler when its sound declares `doppler`. Cheap to call every
+     * tick (~60 Hz) — the shell ramps rate/gain/cutoffs over ~20 ms to avoid zipper noise. A no-op when `id`
+     * is not a live loop (an update may race a stop) (#1051).
      */
     setLoop(id: string, params: {
         rate?: number;
         gain?: number;
         at?: readonly [number, number, number];
+        velocity?: readonly [number, number, number];
+        lowpass?: number;
+        highpass?: number;
     }): void;
     /** Stop and dispose retained loop `id` (emits `audio.loopStop`); an unknown `id` is ignored (#1051). */
     stopLoop(id: string): void;
@@ -442,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;
@@ -555,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/gameRuntime.d.ts

@@ -1,5 +1,5 @@
 import type { SaveConfig } from "./save.js";
-import type { CommandDef, CommandScope } from "./commandRunner.js";
+import type { CommandAccess, CommandDef, CommandScope } from "./commandRunner.js";
 import { runCommand } from "./commandRunner.js";
 import { type GameRuntimeSnapshot, type RuntimeChunkRow, type RuntimePlayerRow, type RuntimeProfileRow, type RuntimeServerRow } from "./snapshot.js";
 export type ServerLoopHooks = {
@@ -69,6 +69,8 @@ export type GameRuntime = {
      * and nothing else. Missing scopes load only the actor and no chunks; `{}` explicitly requests all state.
      */
     commandScope: (commandName: string, input: unknown, actorUserId: string) => CommandScope | undefined;
+    /** Who may send a command, or `undefined` when the runtime has no command by that name. */
+    commandAccess: (commandName: string) => CommandAccess | undefined;
     /** What a join has to hydrate. `undefined` means the whole world, as when `onNewPlayer` is unscoped. */
     joinScope: (userId: string, isNew: boolean) => CommandScope | undefined;
     /** `nowMs` is the host wall clock at the start of the tick, in ms; defaults to `Date.now()`. */

package/dist/runtime/gameRuntime.js

@@ -38,6 +38,10 @@ export function createGameRuntime(definition) {
         commandScope(commandName, input, actorUserId) {
             return resolveCommandScope(definition.commands, commandName, input, actorUserId);
         },
+        commandAccess(commandName) {
+            const command = definition.commands[commandName];
+            return command === undefined ? undefined : (command.access ?? "client");
+        },
         joinScope(userId, isNew) {
             if (!loop?.onNewPlayer)
                 return { players: [userId], chunkKeys: [] };

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[];