@jgengine/core 0.7.0 → 0.9.0

package/dist/runtime/gameContext.d.ts

@@ -1,3 +1,4 @@
+import { type CardPile, type CardPileConfig } from "../cards/cardPile.js";
 import { type OnDeathSpec } from "../combat/death.js";
 import { type EffectInput, type EffectResult, type EffectVia, type ReceiveMap, type SingleTargetEffectInput } from "../combat/effects.js";
 import { type ProjectileSystem } from "../combat/projectiles.js";
@@ -6,6 +7,7 @@ import { type TelegraphShape } from "../combat/telegraph.js";
 import { type CommandDefinition, type CommandResult } from "../commands/commandRegistry.js";
 import { type Cosmetics } from "../game/cosmetics.js";
 import type { GameDefinition } from "../game/defineGame.js";
+import { type TerrainField } from "../world/terrain.js";
 import { type GameEventMap, type GameEvents } from "../game/events.js";
 import { type GameFeed } from "../game/feed.js";
 import { type Leaderboard } from "../game/leaderboard.js";
@@ -13,6 +15,7 @@ import { type Loadouts } from "../game/loadout.js";
 import { type Drop, type LootTableDef } from "../game/lootTable.js";
 import { type QuestJournal } from "../game/quest.js";
 import { type WorldItemRecord, type WorldItemSpawnInput } from "../game/worldItem.js";
+import { type Chat } from "../game/chat.js";
 import { type Social } from "../game/social.js";
 import { type TradeField, type TradeSystem } from "../game/trade.js";
 import { type Unlocks } from "../game/unlocks.js";
@@ -23,16 +26,26 @@ import { type ItemUseHandler, type ItemUseInput, type ItemUseRejection, type Ite
 import { type WeaponStats } from "../item/weapon.js";
 import { type PoseAllowedStates, type PoseState } from "../movement/poseState.js";
 import type { ModelAssetRef } from "../scene/assetCatalog.js";
+import { type PaintLayer } from "../scene/paintLayer.js";
 import { type EntityStatsApi, type StatCatalog } from "../scene/entityStats.js";
-import type { EntityPose, EntityPosition, SceneEntity, SpawnOptions } from "../scene/entityStore.js";
+import type { EntityPose, EntityPosition, EntityStore, SceneEntity, SpawnOptions, SpawnPose } from "../scene/entityStore.js";
 import { type Forms } from "../scene/form.js";
+import type { EntityColliderSet } from "../scene/colliders.js";
+import { type ObjectRaycastHit, type ObjectRaycastInput } from "../scene/objectQuery.js";
 import { type ObjectStore } from "../scene/objectStore.js";
 import { type Roster } from "../scene/roster.js";
 import { type Possession } from "../scene/possession.js";
+import { type SceneRaycastHit, type SceneRaycastInput } from "../scene/sceneRaycast.js";
 import { type SpatialApi } from "../scene/spatial.js";
 import { type CycleTargetOptions } from "../scene/targeting.js";
 import { type Stats } from "../stats/statModifiers.js";
+import { type ObservableKeyedStore } from "../store/observableKeyedStore.js";
 import { type SimClock } from "../time/simClock.js";
+import { type TurnLoop, type TurnLoopConfig } from "../turn/turnLoop.js";
+import { RaceState, type RaceStateConfig } from "../game/race.js";
+import { type CameraDirector } from "./cameraDirector.js";
+import { type InputSnapshot } from "./inputSnapshot.js";
+import { type MotionIntents } from "./motionIntents.js";
 export interface GameContextItemEntry {
     use?: string;
     weapon?: Record<string, unknown>;
@@ -53,6 +66,8 @@ export interface GameContextEntityEntry {
     role?: CatalogEntityRole;
     /** Right-click context-menu verbs for this entity (#31). */
     verbs?: readonly ContextVerb[];
+    /** Purpose-specific colliders (physical body + named damage hitboxes). */
+    colliders?: EntityColliderSet;
 }
 export interface GameContextObjectEntry {
     proximityPrompt?: ProximityPrompt;
@@ -62,6 +77,8 @@ export interface GameContextObjectEntry {
     slotInventory?: InventoryLayout;
     /** Right-click context-menu verbs for this object (#31). */
     verbs?: readonly ContextVerb[];
+    colliders?: EntityColliderSet;
+    halfExtents?: readonly [number, number, number];
 }
 export interface GameContextContent {
     itemById?(itemId: string): GameContextItemEntry | null | undefined;
@@ -76,9 +93,14 @@ export interface GameContextOptions<TAssetRef extends ModelAssetRef = ModelAsset
         isNew: boolean;
     };
     now?: () => number;
+    occluder?: (from: EntityPosition, to: EntityPosition) => boolean;
 }
 export interface SceneObjectContext extends ObjectStore {
     catalog(instanceId: string): GameContextObjectEntry | null;
+    raycast(input: ObjectRaycastInput): ObjectRaycastHit | null;
+    raycastAll(input: ObjectRaycastInput): readonly ObjectRaycastHit[];
+    setColliders(instanceId: string, colliders: EntityColliderSet | null): void;
+    collidersOf(instanceId: string): EntityColliderSet | null;
 }
 export interface FloatTextInput {
     instanceId?: string;
@@ -115,9 +137,14 @@ export interface HitReactionInput {
 export interface SceneEntityContext {
     spawn(name: string, options?: SpawnOptions): string;
     despawn(instanceId: string): boolean;
+    update: EntityStore["update"];
     setPose(instanceId: string, pose: EntityPose): boolean;
+    setPoseConstraint: EntityStore["setPoseConstraint"];
     get(instanceId: string): SceneEntity | null;
     list(): readonly SceneEntity[];
+    spawnPoseOf(instanceId: string): SpawnPose | null;
+    resetToSpawn(instanceId: string): boolean;
+    resetAllToSpawn(filter?: (entity: SceneEntity) => boolean): number;
     stats: EntityStatsApi;
     floatText(input: FloatTextInput): void;
     telegraph(input: TelegraphInput): () => void;
@@ -125,7 +152,7 @@ export interface SceneEntityContext {
     setTarget(fromId: string, toId: string | null): void;
     getTarget(fromId: string): string | null;
     cycleTarget(fromId: string, options?: CycleTargetOptions): string | null;
-    canReceive(instanceId: string, effect: string): string | null;
+    canReceive(instanceId: string, effect: string, magnitude?: number): string | null;
     preview(input: SingleTargetEffectInput): number;
     effect(input: EffectInput): EffectResult[];
     willHitProjectile: ProjectileSystem["willHitProjectile"];
@@ -136,7 +163,11 @@ export interface SceneEntityContext {
     hasLineOfSight: SpatialApi["hasLineOfSight"];
     queryArc: SpatialApi["queryArc"];
     moveToward: SpatialApi["moveToward"];
+    invalidateSpatial: SpatialApi["invalidate"];
+    setColliders(instanceId: string, colliders: EntityColliderSet | null): void;
+    collidersOf(instanceId: string): EntityColliderSet | null;
     form: Forms;
+    paint: PaintLayer;
 }
 export type WorldItemPickupResult = {
     status: "ok";
@@ -151,6 +182,7 @@ export interface SceneWorldItemContext {
     list(): readonly WorldItemRecord[];
     nearestInRadius(from: EntityPosition, radius: number, filter?: (record: WorldItemRecord) => boolean): string | null;
     pickup(instanceId: string, userId: string): WorldItemPickupResult;
+    consume(instanceId: string): WorldItemRecord | null;
 }
 export interface GameContextCommands {
     define<TInput>(name: string, definition: CommandDefinition<GameContext, TInput>): void;
@@ -180,12 +212,31 @@ export interface GameContextItemUse {
     can(input: ItemUseInput): ItemUseRejection | null;
     use(input: ItemUseInput): ItemUseResult<GameContext>;
 }
+export interface GameContextWorld {
+    ground: TerrainField;
+    groundHeightAt(x: number, z: number): number;
+}
+export interface GameContextCards {
+    /** Lazily creates (on first call, `config` required) or returns the existing notify-wrapped pile for `id`. */
+    pile(id: string, config?: CardPileConfig): CardPile;
+}
+export interface GameContextTurn {
+    /** Lazily creates (on first call, `config` required) or returns the existing notify-wrapped turn loop for `id`. */
+    loop(id: string, config?: TurnLoopConfig): TurnLoop;
+}
+export interface GameContextRace {
+    /** Lazily creates (on first call, `config` required) or returns the existing reactive race for `id` — discrete mutations and eventful `update` calls bump `ctx.version()`, so HUDs stop hand-managing `store.set` (#286.2). */
+    state(id: string, config?: RaceStateConfig): RaceState;
+}
 export interface GameContext {
     scene: {
         object: SceneObjectContext;
         entity: SceneEntityContext;
         worldItem: SceneWorldItemContext;
+        raycast(input: SceneRaycastInput): SceneRaycastHit | null;
+        raycastAll(input: SceneRaycastInput): readonly SceneRaycastHit[];
     };
+    world: GameContextWorld;
     game: {
         commands: GameContextCommands;
         events: GameEvents;
@@ -194,10 +245,16 @@ export interface GameContext {
         trade: TradeSystem;
         quest: QuestJournal;
         social: Social;
+        chat: Chat;
         unlocks: Unlocks;
         economy: GameContextEconomy;
         leaderboard: Leaderboard;
         roster: Roster;
+        /** Game-defined keyed reactive store slot (#163.1); mutations bump `ctx.version()`/notify `ctx.subscribe`. */
+        store: ObservableKeyedStore<unknown>;
+        cards: GameContextCards;
+        turn: GameContextTurn;
+        race: GameContextRace;
     };
     player: {
         userId: string;
@@ -211,12 +268,18 @@ export interface GameContext {
         movement: PoseState;
         possession: Possession;
         cosmetics: Cosmetics;
+        /** Vertical-motion seam into the shell-owned FrameDriver (#162.4); see `MotionIntents`. */
+        motion: MotionIntents;
     };
     item: {
         use: GameContextItemUse;
         weapon: WeaponStats;
     };
     time: SimClock;
+    /** Runtime camera-follow/cinematic override (#196.2); the shell reads `followedEntityId()` each frame. */
+    camera: CameraDirector;
+    /** Held-input snapshot published by the shell each frame before `onTick` (#164.1). */
+    input: InputSnapshot;
     subscribe(listener: () => void): () => void;
     version(): number;
 }

package/dist/runtime/gameContext.js

@@ -1,3 +1,4 @@
+import { createCardPile } from "../cards/cardPile.js";
 import { createDeathSystem, deathReasonFromEffect, normalizeOnDeath } from "../combat/death.js";
 import { createEffectSystem, } from "../combat/effects.js";
 import { createProjectileSystem } from "../combat/projectiles.js";
@@ -6,6 +7,7 @@ import { pointInTelegraph, } from "../combat/telegraph.js";
 import { createCommandRegistry, } from "../commands/commandRegistry.js";
 import { balance as walletBalance, canAfford as walletCanAfford, charge as walletCharge, chargeAll as walletChargeAll, createEmptyWallet, grant as walletGrant, } from "../economy/wallet.js";
 import { createCosmetics } from "../game/cosmetics.js";
+import { groundFieldFor } from "../world/terrain.js";
 import { createGameEvents } from "../game/events.js";
 import { createGameFeed } from "../game/feed.js";
 import { createLeaderboard } from "../game/leaderboard.js";
@@ -13,6 +15,7 @@ import { createLoadouts } from "../game/loadout.js";
 import { createLootRegistry, grantDrops } from "../game/lootTable.js";
 import { createQuestJournal } from "../game/quest.js";
 import { createWorldItemStore, resolveDeathDrops, DEFAULT_RARITY, WORLD_ITEM_ENTITY_NAME, } from "../game/worldItem.js";
+import { createChat } from "../game/chat.js";
 import { createSocial } from "../game/social.js";
 import { createTradeSystem } from "../game/trade.js";
 import { createUnlocks } from "../game/unlocks.js";
@@ -20,21 +23,32 @@ import { createInventorySet, putItem, } from "../inventory/inventoryModel.js";
 import { createItemUse, } from "../item/use.js";
 import { createWeaponStats } from "../item/weapon.js";
 import { createPoseState } from "../movement/poseState.js";
+import { createPaintLayer } from "../scene/paintLayer.js";
 import { createEntityStatsApi, seedStatValues, setStatValue, } from "../scene/entityStats.js";
 import { createForms } from "../scene/form.js";
+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";
 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);
     const entities = definition.scene;
     const objects = createObjectStore();
     entities.subscribe(signal.notify);
@@ -57,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";
@@ -71,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 = {
@@ -84,7 +166,7 @@ export function createGameContext(options) {
             signal.notify();
         },
     };
-    const feed = createGameFeed();
+    const feed = createGameFeed(definition.feed);
     const lootRegistry = createLootRegistry();
     const unlocks = notifyAfter(createUnlocks(), ["grant", "hydrate"], signal.notify);
     const rawSocial = createSocial({
@@ -96,11 +178,22 @@ export function createGameContext(options) {
         },
     });
     const social = {
-        friends: notifyAfter(rawSocial.friends, ["request", "accept", "remove", "block", "hydrate"], signal.notify),
-        party: notifyAfter(rawSocial.party, ["invite", "accept", "kick", "leave", "promote"], signal.notify),
+        friends: notifyAfter(rawSocial.friends, ["request", "accept", "decline", "remove", "block", "hydrate"], signal.notify),
+        party: notifyAfter(rawSocial.party, ["invite", "accept", "decline", "kick", "leave", "promote"], signal.notify),
         presence: rawSocial.presence,
         emotes: rawSocial.emotes,
+        worldInvites: notifyAfter(rawSocial.worldInvites, ["invite", "accept", "decline"], signal.notify),
     };
+    const chat = notifyAfter(createChat({
+        events,
+        now,
+        party: rawSocial.party,
+        proximity: {
+            entities: { get: (id) => entities.get(id) },
+            spatial: { inRadius: (center, radius, filter) => spatial.inRadius(center, radius, filter) },
+        },
+        blockedBy: (userId) => rawSocial.friends.snapshot(userId).blocked,
+    }), ["register", "send", "whisper", "hydrate"], signal.notify);
     const leaderboard = notifyAfter(createLeaderboard(), ["increment", "hydrate"], signal.notify);
     const roster = notifyAfter(createRoster({ now }), ["capture", "release", "setEquipped", "hydrate"], signal.notify);
     const playerStats = createStats({});
@@ -110,6 +203,7 @@ export function createGameContext(options) {
     const possession = notifyAfter(createPossession({ entities, events }), ["possess", "own", "disown"], signal.notify);
     const forms = notifyAfter(createForms({ entities, time, events }), ["shapeshift", "revert"], signal.notify);
     const cosmetics = notifyAfter(createCosmetics({ events }), ["apply", "equip", "hydrate"], signal.notify);
+    const paintLayer = notifyAfter(createPaintLayer(), ["paint", "clear"], signal.notify);
     const inventoryDeclarations = definition.inventories ?? {};
     const inventoryIds = Object.keys(inventoryDeclarations);
     const layouts = {};
@@ -259,13 +353,24 @@ export function createGameContext(options) {
         statsByInstance.delete(instanceId);
         targeting.clearAll(instanceId);
         pose.clear(instanceId);
+        entityColliders.delete(instanceId);
         return existed;
     }
+    function resetAllToSpawn(filter) {
+        let count = 0;
+        for (const entity of entities.list()) {
+            if (filter !== undefined && !filter(entity))
+                continue;
+            if (entities.resetToSpawn(entity.id))
+                count += 1;
+        }
+        return count;
+    }
     const worldItems = notifyAfter(createWorldItemStore({
         spawnEntity: (position) => entities.spawn(WORLD_ITEM_ENTITY_NAME, { position, role: "prop" }),
         despawnEntity,
         resolvePosition: (instanceId) => entities.get(instanceId)?.position,
-    }), ["spawn", "take"], signal.notify);
+    }), ["spawn", "take", "remove"], signal.notify);
     function spawnWorldItem(input) {
         const record = worldItems.spawn(input);
         events.emit("worldItem.dropped", {
@@ -389,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({
@@ -406,6 +512,10 @@ export function createGameContext(options) {
                 });
             }
         });
+        return () => {
+            cancelEffect();
+            cancelVisual();
+        };
     }
     function applyHitReaction(input) {
         const attacker = entities.get(input.from);
@@ -466,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", {
@@ -484,16 +635,111 @@ export function createGameContext(options) {
     const sceneObjects = {
         ...objects,
         catalog: (instanceId) => catalogObject(instanceId) ?? null,
+        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();
+    function pile(id, config) {
+        const existing = cardPiles.get(id);
+        if (existing !== undefined)
+            return existing;
+        if (config === undefined) {
+            throw new Error(`cardPile "${id}" has not been created yet; pass a config on first access`);
+        }
+        const created = notifyAfter(createCardPile(config), ["shuffle", "draw", "discard", "exhaust", "move", "reset"], signal.notify);
+        cardPiles.set(id, created);
+        return created;
+    }
+    const turnLoops = new Map();
+    function loop(id, config) {
+        const existing = turnLoops.get(id);
+        if (existing !== undefined)
+            return existing;
+        if (config === undefined) {
+            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", "discard", "clear"], signal.notify);
+        const wrapped = {
+            ...notifyAfter(raw, [
+                "setOrder",
+                "addParticipant",
+                "removeParticipant",
+                "advancePhase",
+                "advanceTurn",
+                "advanceRound",
+                "spend",
+                "gain",
+                "refill",
+                "restore",
+            ], signal.notify),
+            commit: wrappedCommit,
+        };
+        turnLoops.set(id, wrapped);
+        return wrapped;
+    }
+    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 = {
         scene: {
             object: sceneObjects,
             entity: {
                 spawn: spawnEntity,
                 despawn: despawnEntity,
+                update: entities.update,
                 setPose: entities.setPose,
+                setPoseConstraint: entities.setPoseConstraint,
                 get: entities.get,
                 list: entities.list,
+                spawnPoseOf: entities.spawnPoseOf,
+                resetToSpawn: entities.resetToSpawn,
+                resetAllToSpawn,
                 stats: entityStats,
                 floatText: emitFloatText,
                 telegraph: fireTelegraph,
@@ -512,7 +758,17 @@ 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,
             },
             worldItem: {
                 spawn: spawnWorldItem,
@@ -520,7 +776,14 @@ export function createGameContext(options) {
                 list: worldItems.list,
                 nearestInRadius: worldItems.nearestInRadius,
                 pickup: pickupWorldItem,
+                consume: worldItems.remove,
             },
+            raycast: (input) => sceneRaycast.raycast(input),
+            raycastAll: (input) => sceneRaycast.raycastAll(input),
+        },
+        world: {
+            ground,
+            groundHeightAt: ground.sampleHeight,
         },
         game: {
             commands: {
@@ -552,10 +815,15 @@ export function createGameContext(options) {
             trade,
             quest,
             social,
+            chat,
             unlocks,
             economy,
             leaderboard,
             roster,
+            store,
+            cards: { pile },
+            turn: { loop },
+            race: { state: raceState },
         },
         player: {
             userId: player.userId,
@@ -567,6 +835,7 @@ export function createGameContext(options) {
             movement: pose,
             possession,
             cosmetics,
+            motion,
         },
         item: {
             use: {
@@ -582,6 +851,8 @@ export function createGameContext(options) {
             weapon,
         },
         time,
+        camera,
+        input,
         subscribe: signal.subscribe,
         version: signal.version,
     };

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;