@jgengine/core 0.7.0 → 0.8.0

package/dist/puzzle/fallingPiece.js

@@ -0,0 +1,51 @@
+import { cellAt } from "./cellGrid.js";
+export function pieceCells(table, piece) {
+    const rotations = table[piece.shape];
+    const index = ((piece.rotation % rotations.length) + rotations.length) % rotations.length;
+    const state = rotations[index];
+    return state.map(([ox, oy]) => [piece.x + ox, piece.y + oy]);
+}
+export function pieceCollides(grid, table, piece) {
+    for (const [x, y] of pieceCells(table, piece)) {
+        if (x < 0 || x >= grid.width || y >= grid.height)
+            return true;
+        if (y >= 0 && cellAt(grid, x, y) !== null)
+            return true;
+    }
+    return false;
+}
+export function mergePiece(grid, table, piece, value) {
+    const cells = grid.cells.slice();
+    for (const [x, y] of pieceCells(table, piece)) {
+        if (x >= 0 && x < grid.width && y >= 0 && y < grid.height)
+            cells[y * grid.width + x] = value;
+    }
+    return { width: grid.width, height: grid.height, cells };
+}
+export function dropDistance(grid, table, piece) {
+    let distance = 0;
+    while (!pieceCollides(grid, table, { ...piece, y: piece.y + distance + 1 }))
+        distance += 1;
+    return distance;
+}
+export function gravityInterval(level, base = 0.8, perLevel = 0.07, min = 0.05) {
+    return Math.max(min, base - level * perLevel);
+}
+export function levelForLines(lines, linesPerLevel = 10) {
+    return Math.floor(lines / linesPerLevel);
+}
+const CLASSIC_LINE_SCORE = [0, 40, 100, 300, 1200];
+export function lineScore(cleared, level, table = CLASSIC_LINE_SCORE) {
+    return (table[cleared] ?? 0) * (level + 1);
+}
+export function createLockDelay(delaySeconds) {
+    return { delaySeconds, elapsed: 0 };
+}
+export function stepLockDelay(state, grounded, dt) {
+    if (!grounded)
+        return { state: { ...state, elapsed: 0 }, locked: false };
+    const elapsed = state.elapsed + dt;
+    if (elapsed >= state.delaySeconds)
+        return { state: { ...state, elapsed: 0 }, locked: true };
+    return { state: { ...state, elapsed }, locked: false };
+}

package/dist/random/nameGen.d.ts

@@ -0,0 +1,18 @@
+export interface SyllableBank {
+    onset?: readonly string[];
+    nucleus: readonly string[];
+    coda?: readonly string[];
+}
+export interface NameGeneratorOptions {
+    rng: () => number;
+    syllables: SyllableBank;
+    minSyllables?: number;
+    maxSyllables?: number;
+    capitalize?: boolean;
+}
+export interface NameGenerator {
+    name(): string;
+}
+export declare function pickFrom(rng: () => number, bank: readonly string[]): string;
+export declare function createNameGenerator(options: NameGeneratorOptions): NameGenerator;
+export declare function fillTemplate(template: string, vars: Record<string, () => string> | Record<string, string>): string;

package/dist/random/nameGen.js

@@ -0,0 +1,35 @@
+export function pickFrom(rng, bank) {
+    if (bank.length === 0)
+        throw new Error("pickFrom: bank must not be empty");
+    return bank[Math.floor(rng() * bank.length)];
+}
+export function createNameGenerator(options) {
+    const { rng, syllables } = options;
+    const minSyllables = Math.max(1, options.minSyllables ?? 2);
+    const maxSyllables = Math.max(minSyllables, options.maxSyllables ?? minSyllables);
+    const capitalize = options.capitalize ?? true;
+    function syllable() {
+        const onset = syllables.onset === undefined || syllables.onset.length === 0 ? "" : pickFrom(rng, syllables.onset);
+        const nucleus = pickFrom(rng, syllables.nucleus);
+        const coda = syllables.coda === undefined || syllables.coda.length === 0 ? "" : pickFrom(rng, syllables.coda);
+        return `${onset}${nucleus}${coda}`;
+    }
+    return {
+        name() {
+            const span = maxSyllables - minSyllables;
+            const count = minSyllables + (span === 0 ? 0 : Math.floor(rng() * (span + 1)));
+            let result = "";
+            for (let i = 0; i < count; i++)
+                result += syllable();
+            return capitalize && result.length > 0 ? result.charAt(0).toUpperCase() + result.slice(1) : result;
+        },
+    };
+}
+export function fillTemplate(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+        if (!(key in vars))
+            return match;
+        const value = vars[key];
+        return typeof value === "function" ? value() : value;
+    });
+}

package/dist/random/rng.d.ts

@@ -0,0 +1,2 @@
+export declare function seededRng(seed: string | number): () => number;
+export declare function seededStreams(seed: string | number): (stream: string) => () => number;

package/dist/random/rng.js

@@ -0,0 +1,23 @@
+function hashSeed(seed) {
+    const text = typeof seed === "number" ? seed.toString() : seed;
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function seededRng(seed) {
+    let a = hashSeed(seed) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function seededStreams(seed) {
+    const base = typeof seed === "number" ? seed.toString() : seed;
+    return (stream) => seededRng(`${base}:${stream}`);
+}

package/dist/runtime/adapter.d.ts

@@ -5,6 +5,20 @@ export type MultiplayerAdapterConfig = {
 } | {
     kind: "ws";
     topology?: MultiplayerTopology;
+    url?: string;
+} | {
+    kind: "socketio";
+    topology?: MultiplayerTopology;
+    url?: string;
+} | {
+    kind: "p2p";
+    topology?: MultiplayerTopology;
+    room?: string;
+} | {
+    kind: "lan";
+    topology?: MultiplayerTopology;
+    port?: number;
+    path?: string;
 } | {
     kind: "offline";
 };
@@ -13,8 +27,29 @@ export declare function convex(config?: {
 }): MultiplayerAdapterConfig;
 export declare function ws(config?: {
     topology?: MultiplayerTopology;
+    url?: string;
+}): MultiplayerAdapterConfig;
+export declare function fly(config: {
+    app: string;
+    topology?: MultiplayerTopology;
+    path?: string;
+}): MultiplayerAdapterConfig;
+export declare function socketIo(config?: {
+    topology?: MultiplayerTopology;
+    url?: string;
+}): MultiplayerAdapterConfig;
+export declare function p2p(config?: {
+    topology?: MultiplayerTopology;
+    room?: string;
+}): MultiplayerAdapterConfig;
+export declare function lan(config?: {
+    topology?: MultiplayerTopology;
+    port?: number;
+    path?: string;
 }): MultiplayerAdapterConfig;
 export declare function offline(): MultiplayerAdapterConfig;
+export declare function adapterOf(multiplayer: unknown): MultiplayerAdapterConfig | null;
+export declare function multiplayerAdapterKind(multiplayer: unknown): string | null;
 export type ServersPoolConfig = {
     maxServers: number;
     slotsPerServer: number;

package/dist/runtime/adapter.js

@@ -2,11 +2,47 @@ export function convex(config) {
     return { kind: "convex", topology: config?.topology ?? "shared" };
 }
 export function ws(config) {
-    return { kind: "ws", topology: config?.topology ?? "shared" };
+    return { kind: "ws", topology: config?.topology ?? "shared", url: config?.url };
+}
+export function fly(config) {
+    return {
+        kind: "ws",
+        topology: config.topology ?? "shared",
+        url: `wss://${config.app}.fly.dev${config.path ?? "/ws"}`,
+    };
+}
+export function socketIo(config) {
+    return { kind: "socketio", topology: config?.topology ?? "shared", url: config?.url };
+}
+export function p2p(config) {
+    return { kind: "p2p", topology: config?.topology ?? "private", room: config?.room };
+}
+export function lan(config) {
+    return { kind: "lan", topology: config?.topology ?? "shared", port: config?.port, path: config?.path };
 }
 export function offline() {
     return { kind: "offline" };
 }
+const ADAPTER_KINDS = new Set(["convex", "ws", "socketio", "p2p", "lan", "offline"]);
+function isAdapterConfig(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const kind = value.kind;
+    return typeof kind === "string" && ADAPTER_KINDS.has(kind);
+}
+export function adapterOf(multiplayer) {
+    if (isAdapterConfig(multiplayer))
+        return multiplayer;
+    if (typeof multiplayer === "object" && multiplayer !== null) {
+        const nested = multiplayer.adapter;
+        if (isAdapterConfig(nested))
+            return nested;
+    }
+    return null;
+}
+export function multiplayerAdapterKind(multiplayer) {
+    return adapterOf(multiplayer)?.kind ?? null;
+}
 export function servers(config) {
     return config;
 }

package/dist/runtime/cameraDirector.d.ts

@@ -0,0 +1,10 @@
+import type { CinematicCameraConfig } from "../game/playableGame.js";
+export interface CameraDirector {
+    follow(entityId: string | null): void;
+    /** `undefined` means no runtime override — the shell falls back to the static `playable.camera.followEntityId`. `null` means explicitly follow nothing. */
+    followedEntityId(): string | null | undefined;
+    setCinematic(config: CinematicCameraConfig | null): void;
+    cinematic(): CinematicCameraConfig | null;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createCameraDirector(): CameraDirector;

package/dist/runtime/cameraDirector.js

@@ -0,0 +1,25 @@
+export function createCameraDirector() {
+    const listeners = new Set();
+    let followEntity = undefined;
+    let cinematicConfig = null;
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    return {
+        follow(entityId) {
+            followEntity = entityId;
+            notify();
+        },
+        followedEntityId: () => followEntity,
+        setCinematic(config) {
+            cinematicConfig = config;
+            notify();
+        },
+        cinematic: () => cinematicConfig,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

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,23 @@ 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 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 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 { 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>;
@@ -79,6 +89,8 @@ export interface GameContextOptions<TAssetRef extends ModelAssetRef = ModelAsset
 }
 export interface SceneObjectContext extends ObjectStore {
     catalog(instanceId: string): GameContextObjectEntry | null;
+    raycast(input: ObjectRaycastInput): ObjectRaycastHit | null;
+    raycastAll(input: ObjectRaycastInput): readonly ObjectRaycastHit[];
 }
 export interface FloatTextInput {
     instanceId?: string;
@@ -115,9 +127,13 @@ 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;
     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 +141,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"];
@@ -137,6 +153,7 @@ export interface SceneEntityContext {
     queryArc: SpatialApi["queryArc"];
     moveToward: SpatialApi["moveToward"];
     form: Forms;
+    paint: PaintLayer;
 }
 export type WorldItemPickupResult = {
     status: "ok";
@@ -151,6 +168,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 +198,25 @@ 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 GameContext {
     scene: {
         object: SceneObjectContext;
         entity: SceneEntityContext;
         worldItem: SceneWorldItemContext;
     };
+    world: GameContextWorld;
     game: {
         commands: GameContextCommands;
         events: GameEvents;
@@ -194,10 +225,15 @@ 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;
     };
     player: {
         userId: string;
@@ -211,12 +247,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,8 +23,10 @@ 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";
@@ -29,12 +34,18 @@ 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 { 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 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);
@@ -84,7 +95,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 +107,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 +132,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 = {};
@@ -261,11 +284,21 @@ export function createGameContext(options) {
         pose.clear(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", {
@@ -484,16 +517,66 @@ export function createGameContext(options) {
     const sceneObjects = {
         ...objects,
         catalog: (instanceId) => catalogObject(instanceId) ?? null,
+        raycast: (input) => raycastObjects(objects.list(), input),
+        raycastAll: (input) => raycastObjectsAll(objects.list(), input),
     };
+    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", "rewind", "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;
+    }
+    const camera = notifyAfter(createCameraDirector(), ["follow", "setCinematic"], signal.notify);
+    const input = createInputSnapshot();
+    const motion = createMotionIntents();
     const ctx = {
         scene: {
             object: sceneObjects,
             entity: {
                 spawn: spawnEntity,
                 despawn: despawnEntity,
+                update: entities.update,
                 setPose: entities.setPose,
                 get: entities.get,
                 list: entities.list,
+                spawnPoseOf: entities.spawnPoseOf,
+                resetToSpawn: entities.resetToSpawn,
+                resetAllToSpawn,
                 stats: entityStats,
                 floatText: emitFloatText,
                 telegraph: fireTelegraph,
@@ -513,6 +596,7 @@ export function createGameContext(options) {
                 queryArc: spatial.queryArc,
                 moveToward: spatial.moveToward,
                 form: forms,
+                paint: paintLayer,
             },
             worldItem: {
                 spawn: spawnWorldItem,
@@ -520,8 +604,13 @@ export function createGameContext(options) {
                 list: worldItems.list,
                 nearestInRadius: worldItems.nearestInRadius,
                 pickup: pickupWorldItem,
+                consume: worldItems.remove,
             },
         },
+        world: {
+            ground,
+            groundHeightAt: ground.sampleHeight,
+        },
         game: {
             commands: {
                 define: commandRegistry.define,
@@ -552,10 +641,14 @@ export function createGameContext(options) {
             trade,
             quest,
             social,
+            chat,
             unlocks,
             economy,
             leaderboard,
             roster,
+            store,
+            cards: { pile },
+            turn: { loop },
         },
         player: {
             userId: player.userId,
@@ -567,6 +660,7 @@ export function createGameContext(options) {
             movement: pose,
             possession,
             cosmetics,
+            motion,
         },
         item: {
             use: {
@@ -582,6 +676,8 @@ export function createGameContext(options) {
             weapon,
         },
         time,
+        camera,
+        input,
         subscribe: signal.subscribe,
         version: signal.version,
     };