@jgengine/core 0.8.0 → 0.9.0

package/dist/runtime/gameContext.js

@@ -30,6 +30,7 @@ import { raycastObjects, raycastObjectsAll } from "../scene/objectQuery.js";
 import { createObjectStore } from "../scene/objectStore.js";
 import { createRoster } from "../scene/roster.js";
 import { createPossession } from "../scene/possession.js";
+import { createSceneRaycast, } from "../scene/sceneRaycast.js";
 import { createSpatialApi } from "../scene/spatial.js";
 import { createTargeting } from "../scene/targeting.js";
 import { createStats } from "../stats/statModifiers.js";
@@ -37,12 +38,14 @@ import { createChangeSignal, notifyAfter } from "../store/changeSignal.js";
 import { createObservableKeyedStore } from "../store/observableKeyedStore.js";
 import { createSimClock } from "../time/simClock.js";
 import { createTurnLoop } from "../turn/turnLoop.js";
+import { RaceState } from "../game/race.js";
 import { createCameraDirector } from "./cameraDirector.js";
 import { createInputSnapshot } from "./inputSnapshot.js";
 import { createMotionIntents } from "./motionIntents.js";
 export function createGameContext(options) {
     const { definition, content, player } = options;
     const now = options.now ?? Date.now;
+    const occluder = options.occluder;
     const signal = createChangeSignal();
     const time = createSimClock({ config: definition.time, onChange: signal.notify });
     const ground = groundFieldFor(definition.world);
@@ -68,12 +71,46 @@ export function createGameContext(options) {
         const object = objects.get(instanceId);
         return object === null ? undefined : content.objectById?.(object.catalogId);
     }
+    let spatialGeneration = 0;
+    const candidateIds = [];
+    let candidateIdsDirty = true;
+    function refreshCandidateIds() {
+        if (!candidateIdsDirty)
+            return candidateIds;
+        candidateIds.length = 0;
+        for (const entity of entities.list())
+            candidateIds.push(entity.id);
+        candidateIdsDirty = false;
+        return candidateIds;
+    }
     const spatial = createSpatialApi({
         resolvePosition: (instanceId) => entities.get(instanceId)?.position,
-        candidates: () => entities.list().map((entity) => entity.id),
+        candidates: refreshCandidateIds,
+        grid: { cellSize: 8 },
+        getVersion: () => spatialGeneration,
+        ...(occluder !== undefined ? { occluder } : {}),
+    });
+    entities.subscribe(() => {
+        candidateIdsDirty = true;
+        spatialGeneration += 1;
+        spatial.invalidate();
     });
+    const entityColliders = new Map();
+    const objectColliders = new Map();
+    function entityCollidersOf(instanceId) {
+        const override = entityColliders.get(instanceId);
+        if (override !== undefined)
+            return override;
+        return catalogEntry(instanceId)?.colliders ?? null;
+    }
+    function objectCollidersOf(instanceId) {
+        const override = objectColliders.get(instanceId);
+        if (override !== undefined)
+            return override;
+        return catalogObject(instanceId)?.colliders ?? null;
+    }
     const targeting = notifyAfter(createTargeting({
-        candidates: () => entities.list().map((entity) => entity.id),
+        candidates: () => [...refreshCandidateIds()],
         classify(_fromId, toId) {
             const role = catalogEntry(toId)?.role;
             return role === "enemy" || role === "hostile" ? "hostile" : "friendly";
@@ -82,9 +119,43 @@ export function createGameContext(options) {
     }), ["setTarget", "cycleTarget"], signal.notify);
     const combatSpatial = {
         inRadius: (center, radius) => spatial.inRadius(center, radius),
-        hasLineOfSight: (from, to) => typeof from === "string" ? spatial.hasLineOfSight(from, to) : entities.get(to) !== null,
+        hasLineOfSight: (from, to) => {
+            if (typeof from === "string")
+                return spatial.hasLineOfSight(from, to);
+            const toPos = entities.get(to)?.position;
+            if (toPos === undefined)
+                return false;
+            if (occluder === undefined)
+                return true;
+            return !occluder(from, toPos);
+        },
         positionOf: (instanceId) => entities.get(instanceId)?.position,
     };
+    const sceneRaycast = createSceneRaycast({
+        entities: {
+            list: () => entities.list().map((entity) => ({
+                id: entity.id,
+                position: entity.position,
+                rotationY: entity.rotationY,
+                name: entity.name,
+            })),
+            collidersOf: entityCollidersOf,
+            inRadius: (center, radius) => spatial.inRadius(center, radius),
+            get: (id) => {
+                const entity = entities.get(id);
+                if (entity === null)
+                    return null;
+                return { id: entity.id, position: entity.position, rotationY: entity.rotationY, name: entity.name };
+            },
+        },
+        objects: {
+            list: () => objects.list(),
+            inBox: (min, max) => objects.inBox(min, max),
+            collidersOf: objectCollidersOf,
+            halfExtentsOf: (catalogId) => content.objectById?.(catalogId)?.halfExtents ?? null,
+        },
+        terrain: ground,
+    });
     const weapon = createWeaponStats((itemId) => content.itemById?.(itemId));
     const rawEvents = createGameEvents();
     const events = {
@@ -282,6 +353,7 @@ export function createGameContext(options) {
         statsByInstance.delete(instanceId);
         targeting.clearAll(instanceId);
         pose.clear(instanceId);
+        entityColliders.delete(instanceId);
         return existed;
     }
     function resetAllToSpawn(filter) {
@@ -422,13 +494,14 @@ export function createGameContext(options) {
         if (input.dir !== undefined)
             telegraphEvent.dir = input.dir;
         events.emit("combat.telegraph", telegraphEvent);
+        const cancelVisual = () => events.emit("combat.telegraphCancelled", { id });
         const bound = input.effect;
         if (bound === undefined)
-            return () => { };
+            return cancelVisual;
         const config = { shape: input.shape, at: input.at, windupMs: input.windupMs };
         if (input.dir !== undefined)
             config.dir = input.dir;
-        return time.after(input.windupMs / 1000, () => {
+        const cancelEffect = time.after(input.windupMs / 1000, () => {
             const targets = entities.list().filter((entity) => pointInTelegraph(config, entity.position));
             for (const target of targets) {
                 applyEffectAndFloat({
@@ -439,6 +512,10 @@ export function createGameContext(options) {
                 });
             }
         });
+        return () => {
+            cancelEffect();
+            cancelVisual();
+        };
     }
     function applyHitReaction(input) {
         const attacker = entities.get(input.from);
@@ -499,10 +576,51 @@ export function createGameContext(options) {
         preview: effects.preview,
         applyEffect: applyEffectAndFloat,
     };
+    const projectileObstacles = definition.physics?.projectileObstacles === true;
+    const projectileSceneRaycast = {
+        raycast(input) {
+            return sceneRaycast.raycast({
+                ...input,
+                filter: {
+                    entities: true,
+                    objects: projectileObstacles,
+                    terrain: false,
+                    walls: projectileObstacles,
+                    ...input.filter,
+                },
+            });
+        },
+        raycastAll(input) {
+            return sceneRaycast.raycastAll({
+                ...input,
+                filter: {
+                    entities: true,
+                    objects: projectileObstacles,
+                    terrain: false,
+                    walls: projectileObstacles,
+                    ...input.filter,
+                },
+            });
+        },
+    };
     const projectiles = notifyAfter(createProjectileSystem({
         effects: floatingEffects,
         spatial: combatSpatial,
         getStat: weapon.getStat,
+        sceneRaycast: projectileSceneRaycast,
+        objects: projectileObstacles
+            ? {
+                list: () => objects.list(),
+                inBox: (min, max) => objects.inBox(min, max),
+                halfExtents: (catalogId) => {
+                    const half = content.objectById?.(catalogId)?.halfExtents;
+                    return half === undefined ? null : [half[0], half[1], half[2]];
+                },
+                collidersOf: objectCollidersOf,
+            }
+            : undefined,
+        entityCollidersOf,
+        rotationYOf: (instanceId) => entities.get(instanceId)?.rotationY,
         now,
         onSettle(report) {
             events.emit("projectile.settled", {
@@ -517,8 +635,16 @@ export function createGameContext(options) {
     const sceneObjects = {
         ...objects,
         catalog: (instanceId) => catalogObject(instanceId) ?? null,
-        raycast: (input) => raycastObjects(objects.list(), input),
-        raycastAll: (input) => raycastObjectsAll(objects.list(), input),
+        raycast: (input) => raycastObjects(objects, input),
+        raycastAll: (input) => raycastObjectsAll(objects, input),
+        setColliders(instanceId, colliders) {
+            if (colliders === null)
+                objectColliders.delete(instanceId);
+            else
+                objectColliders.set(instanceId, colliders);
+            signal.notify();
+        },
+        collidersOf: objectCollidersOf,
     };
     const store = notifyAfter(createObservableKeyedStore(), ["set", "delete"], signal.notify);
     const cardPiles = new Map();
@@ -542,7 +668,7 @@ export function createGameContext(options) {
             throw new Error(`turn loop "${id}" has not been created yet; pass a config on first access`);
         }
         const raw = createTurnLoop(config);
-        const wrappedCommit = notifyAfter(raw.commit, ["submit", "expected", "commit", "rewind", "clear"], signal.notify);
+        const wrappedCommit = notifyAfter(raw.commit, ["submit", "expected", "commit", "discard", "clear"], signal.notify);
         const wrapped = {
             ...notifyAfter(raw, [
                 "setOrder",
@@ -561,7 +687,43 @@ export function createGameContext(options) {
         turnLoops.set(id, wrapped);
         return wrapped;
     }
-    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic"], signal.notify);
+    class NotifyingRaceState extends RaceState {
+        addRacer(racerId, startTime) {
+            super.addRacer(racerId, startTime);
+            signal.notify();
+        }
+        removeRacer(racerId) {
+            super.removeRacer(racerId);
+            signal.notify();
+        }
+        reset() {
+            super.reset();
+            signal.notify();
+        }
+        eliminate(racerId) {
+            super.eliminate(racerId);
+            signal.notify();
+        }
+        update(now, positions) {
+            const raceEvents = super.update(now, positions);
+            if (raceEvents.length > 0)
+                signal.notify();
+            return raceEvents;
+        }
+    }
+    const raceStates = new Map();
+    function raceState(id, config) {
+        const existing = raceStates.get(id);
+        if (existing !== undefined)
+            return existing;
+        if (config === undefined) {
+            throw new Error(`race "${id}" has not been created yet; pass a config on first access`);
+        }
+        const created = new NotifyingRaceState(config);
+        raceStates.set(id, created);
+        return created;
+    }
+    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic", "setChaseTuning"], signal.notify);
     const input = createInputSnapshot();
     const motion = createMotionIntents();
     const ctx = {
@@ -572,6 +734,7 @@ export function createGameContext(options) {
                 despawn: despawnEntity,
                 update: entities.update,
                 setPose: entities.setPose,
+                setPoseConstraint: entities.setPoseConstraint,
                 get: entities.get,
                 list: entities.list,
                 spawnPoseOf: entities.spawnPoseOf,
@@ -595,6 +758,15 @@ export function createGameContext(options) {
                 hasLineOfSight: spatial.hasLineOfSight,
                 queryArc: spatial.queryArc,
                 moveToward: spatial.moveToward,
+                invalidateSpatial: spatial.invalidate,
+                setColliders(instanceId, colliders) {
+                    if (colliders === null)
+                        entityColliders.delete(instanceId);
+                    else
+                        entityColliders.set(instanceId, colliders);
+                    signal.notify();
+                },
+                collidersOf: entityCollidersOf,
                 form: forms,
                 paint: paintLayer,
             },
@@ -606,6 +778,8 @@ export function createGameContext(options) {
                 pickup: pickupWorldItem,
                 consume: worldItems.remove,
             },
+            raycast: (input) => sceneRaycast.raycast(input),
+            raycastAll: (input) => sceneRaycast.raycastAll(input),
         },
         world: {
             ground,
@@ -649,6 +823,7 @@ export function createGameContext(options) {
             store,
             cards: { pile },
             turn: { loop },
+            race: { state: raceState },
         },
         player: {
             userId: player.userId,

package/dist/runtime/gameRuntime.d.ts

@@ -5,7 +5,7 @@ import { type GameRuntimeSnapshot, type RuntimeChunkRow, type RuntimePlayerRow,
 export type ServerLoopHooks = {
     onInit?: (ctx: RuntimeInitContext) => void;
     onNewPlayer?: (ctx: RuntimeLoopContext) => void;
-    onTick?: (ctx: RuntimeLoopContext, dtSeconds: number) => void;
+    onTick?: (ctx: RuntimeWorldContext, dtSeconds: number) => void;
 };
 export type RuntimeInitContext = {
     snapshot: GameRuntimeSnapshot;
@@ -17,6 +17,9 @@ export type RuntimeLoopContext = RuntimeInitContext & {
         isNew: boolean;
     };
 };
+export type RuntimeWorldContext = RuntimeInitContext & {
+    playerIds: readonly string[];
+};
 export type GameRuntimeDefinition = {
     gameId: string;
     save: SaveConfig;
@@ -29,6 +32,7 @@ export type HydrateInput = {
     serverRow: RuntimeServerRow;
     playersByUserId: Record<string, RuntimePlayerRow>;
     chunksByKey: Record<string, RuntimeChunkRow>;
+    revision?: number;
 };
 export type GameRuntime = {
     gameId: string;

package/dist/runtime/gameRuntime.js

@@ -13,6 +13,7 @@ export function createGameRuntime(definition) {
                 server: input.serverRow,
                 players: input.playersByUserId,
                 chunks: input.chunksByKey,
+                revision: input.revision,
             });
             if (loop?.onInit && !initialized) {
                 initialized = true;
@@ -34,18 +35,18 @@ export function createGameRuntime(definition) {
             if (!loop?.onTick)
                 return snapshot;
             let current = snapshot;
-            for (const userId of Object.keys(current.players)) {
-                const ctx = {
-                    get snapshot() {
-                        return current;
-                    },
-                    player: { userId, isNew: false },
-                    setSnapshot(next) {
-                        current = next;
-                    },
-                };
-                loop.onTick(ctx, dtSeconds);
-            }
+            const ctx = {
+                get snapshot() {
+                    return current;
+                },
+                get playerIds() {
+                    return Object.keys(current.players);
+                },
+                setSnapshot(next) {
+                    current = next;
+                },
+            };
+            loop.onTick(ctx, dtSeconds);
             return current;
         },
         joinPlayer(snapshot, userId, isNew) {

package/dist/runtime/hostPersistence.d.ts

@@ -63,6 +63,7 @@ export declare function drainPendingLeaderboardIncrements(session: Record<string
     session: Record<string, unknown>;
 };
 export declare const LEADERBOARD_TOP_LIMIT = 100;
+export declare function clampLimit(value: number | undefined, fallback: number, max: number): number;
 export type LeaderboardRow = {
     gameId: string;
     stat: string;
@@ -97,7 +98,12 @@ export type ServerListing = {
     tags?: string[];
     updatedAt: number;
 };
-export declare function toServerListing(record: GameServerRecord): ServerListing;
+export type ToServerListingOptions = {
+    includeJoinCode?: boolean;
+};
+export declare function toServerListing(record: GameServerRecord, options?: ToServerListingOptions): ServerListing;
+export declare const OPEN_SERVER_LISTING_LIMIT = 20;
+export declare const OPEN_SERVER_LISTING_MAX = 100;
 export declare function toOpenServerListings(listings: Iterable<ServerListing>, limit?: number): ServerListing[];
 export type HostPersistence = {
     savePlan?: (plan: ServerPersistPlan) => Promise<void>;
@@ -112,6 +118,7 @@ export type HostPersistence = {
     saveProfile: (record: PlayerProfileRecord) => Promise<void>;
     loadChunks: (serverId: string) => Promise<WorldChunkRecord[]>;
     saveChunks: (serverId: string, chunks: WorldChunkRecord[]) => Promise<void>;
+    deleteChunks: (serverId: string, chunkKeys: string[]) => Promise<void>;
     loadFeed: (args: {
         serverId: string;
         action: string;
@@ -139,6 +146,7 @@ export type ServerPersistPlan = {
     server: GameServerRecord;
     profiles: PlayerProfileRecord[];
     chunks: WorldChunkRecord[];
+    deletedChunks: string[];
     leaderboard: LeaderboardIncrement[];
 };
 export declare function planServerPersist(server: GameServerRecord, snapshot: GameRuntimeSnapshot, save: SaveConfig, now: number): ServerPersistPlan;

package/dist/runtime/hostPersistence.js

@@ -21,6 +21,12 @@ export function drainPendingLeaderboardIncrements(session) {
     return { increments: raw.filter(isLeaderboardIncrement), session: rest };
 }
 export const LEADERBOARD_TOP_LIMIT = 100;
+export function clampLimit(value, fallback, max) {
+    const candidate = value ?? fallback;
+    if (!Number.isFinite(candidate))
+        return fallback;
+    return Math.min(Math.max(Math.floor(candidate), 1), max);
+}
 export function leaderboardRowKey(row) {
     return [row.gameId, row.scope, row.stat, row.serverId ?? "", row.userId].join("|");
 }
@@ -45,7 +51,7 @@ export function applyLeaderboardRows(rows, gameId, entries, now) {
     }
 }
 export function topLeaderboardRows(rows, args) {
-    const limit = Math.min(Math.max(args.limit ?? LEADERBOARD_TOP_LIMIT, 1), LEADERBOARD_TOP_LIMIT);
+    const limit = clampLimit(args.limit, LEADERBOARD_TOP_LIMIT, LEADERBOARD_TOP_LIMIT);
     return [...rows]
         .filter((row) => row.gameId === args.gameId &&
         row.stat === args.stat &&
@@ -79,7 +85,7 @@ export function shouldAutoSave(save, dirtyAt, lastSavedAt, now) {
     const anchor = lastSavedAt ?? 0;
     return now - anchor >= intervalMs;
 }
-export function toServerListing(record) {
+export function toServerListing(record, options = {}) {
     return {
         serverId: record.serverId,
         status: record.status,
@@ -88,16 +94,20 @@ export function toServerListing(record) {
         mode: record.mode,
         label: record.label,
         visibility: record.visibility,
-        joinCode: record.joinCode,
+        ...(options.includeJoinCode === true && record.joinCode !== undefined
+            ? { joinCode: record.joinCode }
+            : {}),
         tags: record.tags,
         updatedAt: record.updatedAt,
     };
 }
-export function toOpenServerListings(listings, limit = 20) {
+export const OPEN_SERVER_LISTING_LIMIT = 20;
+export const OPEN_SERVER_LISTING_MAX = 100;
+export function toOpenServerListings(listings, limit = OPEN_SERVER_LISTING_LIMIT) {
     return [...listings]
         .filter((listing) => listing.status === "running")
         .sort((a, b) => b.updatedAt - a.updatedAt)
-        .slice(0, limit);
+        .slice(0, clampLimit(limit, OPEN_SERVER_LISTING_LIMIT, OPEN_SERVER_LISTING_MAX));
 }
 export function buildHydratePlayers(server, profiles) {
     const players = {};
@@ -146,12 +156,16 @@ export function planServerPersist(server, snapshot, save, now) {
         }
     }
     const chunks = [];
+    const deletedChunks = [];
     if (isSaveEnabled(save) && saveScopeIncludesChunks(save.scope)) {
         for (const chunkKey of snapshot.dirty.chunks) {
             const chunk = snapshot.chunks[chunkKey];
-            if (!chunk)
-                continue;
-            chunks.push({ serverId: server.serverId, chunkKey, snapshot: chunk, updatedAt: now });
+            if (chunk) {
+                chunks.push({ serverId: server.serverId, chunkKey, snapshot: chunk, updatedAt: now });
+            }
+            else {
+                deletedChunks.push(chunkKey);
+            }
         }
     }
     return {
@@ -166,6 +180,7 @@ export function planServerPersist(server, snapshot, save, now) {
         },
         profiles,
         chunks,
+        deletedChunks,
         leaderboard,
     };
 }

package/dist/runtime/inputSnapshot.d.ts

@@ -1,7 +1,12 @@
+import type { PointerAxisState } from "../input/pointerAxis.js";
 export interface InputSnapshot {
     /** Replaces the held-action set for this frame. Called by the shell before `onTick` each frame; does not bump `ctx.version()` or notify `ctx.subscribe` listeners — per-frame publishes would storm subscribers. */
     publish(held: readonly string[]): void;
+    /** Replaces the normalized pointer-position state for this frame (#293). Same no-notify contract as `publish`. */
+    publishPointer(state: PointerAxisState | null): void;
     isDown(action: string): boolean;
     held(): readonly string[];
+    /** Pointer position over the play surface, `[-1, 1]` per axis with `+y` down, published by the shell each frame; `null` until the first pointer move. */
+    pointer(): PointerAxisState | null;
 }
 export declare function createInputSnapshot(): InputSnapshot;

package/dist/runtime/inputSnapshot.js

@@ -1,12 +1,17 @@
 export function createInputSnapshot() {
     let heldSet = new Set();
     let heldList = [];
+    let pointerState = null;
     return {
         publish(held) {
             heldList = held;
             heldSet = new Set(held);
         },
+        publishPointer(state) {
+            pointerState = state;
+        },
         isDown: (action) => heldSet.has(action),
         held: () => heldList,
+        pointer: () => pointerState,
     };
 }

package/dist/runtime/motionIntents.d.ts

@@ -1,11 +1,14 @@
 /**
- * Seam for game code to reach the vertical motion the shell's FrameDriver
+ * Seam for game code to reach the motion the shell's FrameDriver
  * otherwise owns privately (#162.4). Game code calls `impulse`,
- * `setVerticalVelocity`, and/or `setY` from `onTick` or commands; the shell
- * calls `takePending()` once per frame, before integrating gravity, to drain
- * what accumulated. `setY` wins over physics for that frame; impulses add to
- * the vertical velocity the driver is about to integrate; a later
- * `setVerticalVelocity` replaces that velocity outright.
+ * `pushHorizontal`, `setVerticalVelocity`, and/or `setY` from `onTick` or
+ * commands; the shell calls `takePending()` once per frame, before
+ * integrating gravity, to drain what accumulated. `setY` wins over physics
+ * for that frame; impulses add to the velocity the driver is about to
+ * integrate; a later `setVerticalVelocity` replaces that velocity outright.
+ * Horizontal pushes compose with the walk controller (#282.4): they add to
+ * its horizontal velocity and decay naturally as it re-blends toward input —
+ * knockback, dashes, explosion shoves without raw `setPose` offsets.
  *
  * Intentionally not `ctx.version()`/`ctx.subscribe` wired: these fire at
  * most once per frame and would otherwise storm subscribers with per-frame
@@ -13,13 +16,18 @@
  */
 export interface MotionIntents {
     impulse(velocityY: number): void;
+    /** Adds a horizontal velocity kick (world units/s) that the walk controller integrates and decays. */
+    pushHorizontal(velocityX: number, velocityZ: number): void;
     setVerticalVelocity(velocityY: number): void;
     setY(y: number): void;
     takePending(): MotionIntentBatch | null;
 }
 export interface MotionIntentBatch {
     impulses: readonly number[];
+    horizontalImpulses: readonly (readonly [number, number])[];
     verticalVelocity: number | null;
     y: number | null;
 }
 export declare function createMotionIntents(): MotionIntents;
+/** Fold a batch's horizontal pushes into a controller's velocity pair — shared by the walk and voxel drivers. */
+export declare function applyHorizontalImpulses(velocityX: number, velocityZ: number, batch: MotionIntentBatch | null): readonly [number, number];

package/dist/runtime/motionIntents.js

@@ -1,11 +1,15 @@
 export function createMotionIntents() {
     let impulses = [];
+    let horizontalImpulses = [];
     let verticalVelocity = null;
     let y = null;
     return {
         impulse(velocityY) {
             impulses.push(velocityY);
         },
+        pushHorizontal(velocityX, velocityZ) {
+            horizontalImpulses.push([velocityX, velocityZ]);
+        },
         setVerticalVelocity(velocityY) {
             verticalVelocity = velocityY;
         },
@@ -13,13 +17,27 @@ export function createMotionIntents() {
             y = nextY;
         },
         takePending() {
-            if (impulses.length === 0 && verticalVelocity === null && y === null)
+            if (impulses.length === 0 && horizontalImpulses.length === 0 && verticalVelocity === null && y === null) {
                 return null;
-            const batch = { impulses, verticalVelocity, y };
+            }
+            const batch = { impulses, horizontalImpulses, verticalVelocity, y };
             impulses = [];
+            horizontalImpulses = [];
             verticalVelocity = null;
             y = null;
             return batch;
         },
     };
 }
+/** Fold a batch's horizontal pushes into a controller's velocity pair — shared by the walk and voxel drivers. */
+export function applyHorizontalImpulses(velocityX, velocityZ, batch) {
+    if (batch === null || batch.horizontalImpulses.length === 0)
+        return [velocityX, velocityZ];
+    let x = velocityX;
+    let z = velocityZ;
+    for (const [ix, iz] of batch.horizontalImpulses) {
+        x += ix;
+        z += iz;
+    }
+    return [x, z];
+}

package/dist/runtime/snapshot.d.ts

@@ -77,6 +77,7 @@ export declare function createRuntimeSnapshot(args: {
     server?: RuntimeServerRow;
     players?: Record<string, RuntimePlayerRow>;
     chunks?: Record<string, RuntimeChunkRow>;
+    revision?: number;
 }): GameRuntimeSnapshot;
 export declare function markServerDirty(snapshot: GameRuntimeSnapshot): GameRuntimeSnapshot;
 export declare function markPlayerDirty(snapshot: GameRuntimeSnapshot, userId: string): GameRuntimeSnapshot;

package/dist/runtime/snapshot.js

@@ -24,7 +24,7 @@ export function createRuntimeSnapshot(args) {
         server: args.server ?? createEmptyServerRow(),
         players: args.players ?? {},
         chunks: args.chunks ?? {},
-        revision: 0,
+        revision: args.revision ?? 0,
         dirty: {
             server: false,
             players: [],