@jgengine/core 0.10.0 → 0.12.0

package/dist/runtime/descriptors/features.js

@@ -0,0 +1,299 @@
+import { canAfford as walletCanAfford, chargeAll as walletChargeAll, } from "../../economy/wallet.js";
+import { createCosmetics } from "../../game/cosmetics.js";
+import { createLeaderboard } from "../../game/leaderboard.js";
+import { createGameDialogue } from "../../game/dialogue.js";
+import { createQuestJournal } from "../../game/quest.js";
+import { createChat } from "../../game/chat.js";
+import {} from "../../game/social.js";
+import { createTradeSystem } from "../../game/trade.js";
+import { createUnlocks } from "../../game/unlocks.js";
+import { createRoster } from "../../scene/roster.js";
+import { createConnectedPlayers } from "../../game/connectedPlayers.js";
+import { notifyAfter } from "../../store/changeSignal.js";
+import { decodeArray, decodeRecord } from "../context/snapshotCodecs.js";
+/** @internal */
+export const featureDescriptors = [
+    {
+        key: "unlocks",
+        enabled: (f) => f.unlocks === true,
+        create(d) {
+            const unlocks = notifyAfter(createUnlocks(), ["grant", "hydrate"], d.signalNotify);
+            return {
+                value: unlocks,
+                save: {
+                    key: "unlocks",
+                    snapshot: () => unlocks.snapshotAll(),
+                    decode: (raw) => decodeRecord(raw),
+                    hydrate: (data) => unlocks.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "social",
+        enabled: (f) => f.social === true,
+        create(d) {
+            const raw = d.sharedSocial();
+            const social = {
+                friends: notifyAfter(raw.friends, ["request", "accept", "decline", "remove", "block", "hydrate"], d.signalNotify),
+                party: notifyAfter(raw.party, ["invite", "accept", "decline", "kick", "leave", "promote"], d.signalNotify),
+                presence: raw.presence,
+                emotes: raw.emotes,
+                worldInvites: notifyAfter(raw.worldInvites, ["invite", "accept", "decline"], d.signalNotify),
+                snapshot: raw.snapshot,
+                hydrate: (data) => {
+                    raw.hydrate(data);
+                    d.signalNotify();
+                },
+            };
+            return {
+                value: social,
+                replicate: {
+                    key: "social",
+                    snapshot: () => social.snapshot(),
+                    decode: (rawVal) => {
+                        const rec = decodeRecord(rawVal);
+                        return rec === null ? null : rec;
+                    },
+                    hydrate: (data) => social.hydrate(data),
+                },
+            };
+        },
+    },
+    {
+        key: "chat",
+        enabled: (f) => f.chat === true,
+        create(d) {
+            const raw = d.sharedSocial();
+            const chat = notifyAfter(createChat({
+                events: d.events,
+                now: d.now,
+                party: raw.party,
+                proximity: {
+                    entities: { get: (id) => d.entities.get(id) },
+                    spatial: { inRadius: (center, radius, filter) => d.spatial.inRadius(center, radius, filter) },
+                },
+                blockedBy: (userId) => raw.friends.snapshot(userId).blocked,
+            }), ["register", "send", "whisper", "hydrate"], d.signalNotify);
+            return {
+                value: chat,
+                replicate: {
+                    key: "chat",
+                    snapshot: () => chat.snapshot(),
+                    decode: (rawVal) => {
+                        const rec = decodeRecord(rawVal);
+                        return rec === null ? null : rec;
+                    },
+                    hydrate: (data) => chat.hydrate(data),
+                },
+            };
+        },
+    },
+    {
+        key: "leaderboard",
+        enabled: (f) => f.leaderboard === true,
+        create(d) {
+            const leaderboard = notifyAfter(createLeaderboard(), ["increment", "hydrate"], d.signalNotify);
+            return {
+                value: leaderboard,
+                replicate: {
+                    key: "leaderboard",
+                    snapshot: () => leaderboard.snapshot(),
+                    decode: (raw) => decodeArray(raw),
+                    hydrate: (data) => leaderboard.hydrate(data),
+                },
+            };
+        },
+    },
+    {
+        key: "roster",
+        enabled: (f) => f.roster === true,
+        create(d) {
+            const roster = notifyAfter(createRoster({ now: d.now }), ["capture", "release", "setEquipped", "hydrate"], d.signalNotify);
+            return {
+                value: roster,
+                save: {
+                    key: "roster",
+                    snapshot: () => roster.snapshotAll(),
+                    decode: (raw) => decodeRecord(raw),
+                    hydrate: (data) => roster.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "cosmetics",
+        enabled: (f) => f.cosmetics === true,
+        create(d) {
+            const cosmetics = notifyAfter(createCosmetics({ events: d.events }), ["apply", "equip", "hydrate"], d.signalNotify);
+            return {
+                value: cosmetics,
+                save: {
+                    key: "cosmetics",
+                    snapshot: () => cosmetics.snapshotAll(),
+                    decode: (raw) => decodeRecord(raw),
+                    hydrate: (data) => cosmetics.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "trade",
+        enabled: (f) => f.trade === true,
+        create(d) {
+            return {
+                value: createTradeSystem({
+                    resolveTrade: (itemId) => d.content.itemById?.(itemId)?.trade,
+                    wallet: {
+                        canAfford: (costs) => walletCanAfford(d.walletOf(d.activeUserId()), costs) ? null : "insufficient-funds",
+                        charge(costs) {
+                            const result = walletChargeAll(d.walletOf(d.activeUserId()), costs);
+                            if (result.status === "ok") {
+                                d.setWallet(d.activeUserId(), result.state);
+                                d.signalNotify();
+                            }
+                        },
+                        grant(gains) {
+                            for (const [currencyId, amount] of Object.entries(gains)) {
+                                d.economy.grant(d.activeUserId(), currencyId, amount);
+                            }
+                        },
+                    },
+                    inventory: {
+                        put(inventoryId, itemId, count) {
+                            if (d.layouts[inventoryId] === undefined)
+                                return { reason: `unknown inventory "${inventoryId}"` };
+                            const result = d.inventoryFor(d.activeUserId()).put(inventoryId, itemId, count);
+                            return result.status === "ok" ? null : { reason: result.reason };
+                        },
+                        take(inventoryId, itemId, count) {
+                            if (d.layouts[inventoryId] === undefined)
+                                return { reason: `unknown inventory "${inventoryId}"` };
+                            const result = d.inventoryFor(d.activeUserId()).take(inventoryId, itemId, count);
+                            return result.status === "ok" ? null : { reason: result.reason };
+                        },
+                        count: (inventoryId, itemId) => d.inventoryFor(d.activeUserId()).count(inventoryId, itemId),
+                    },
+                }),
+            };
+        },
+    },
+    {
+        key: "quest",
+        enabled: (f) => f.quest === true,
+        create(d) {
+            const quest = notifyAfter(createQuestJournal({
+                events: d.events,
+                rewards: {
+                    grantXp(userId, amount) {
+                        const existing = d.ensureInstanceStats(userId)["xp"];
+                        const current = (existing?.current ?? 0) + amount;
+                        d.seedUserPool(userId, "xp", { current, max: Math.max(existing?.max ?? 0, current) });
+                    },
+                    grantEconomy: (userId, currencyId, amount) => d.economy.grant(userId, currencyId, amount),
+                    grantItem(userId, inventoryId, itemId, count) {
+                        if (d.layouts[inventoryId] === undefined)
+                            return { reason: `unknown inventory "${inventoryId}"` };
+                        const result = d.inventoryFor(userId).put(inventoryId, itemId, count);
+                        return result.status === "ok" ? null : { reason: result.reason };
+                    },
+                    grantUnlock: (userId, unlockId) => d.feature("unlocks")?.grant(userId, unlockId),
+                },
+                hasUnlock: (userId, id) => d.feature("unlocks")?.has(userId, id) ?? false,
+            }), ["accept", "abandon", "progress", "turnIn", "grant", "revoke", "hydrate"], d.signalNotify);
+            return {
+                value: quest,
+                save: {
+                    key: "quest",
+                    snapshot: () => quest.snapshotAll(),
+                    decode: (raw) => decodeRecord(raw),
+                    hydrate: (data) => quest.hydrateAll(data),
+                },
+            };
+        },
+    },
+    {
+        key: "dialogue",
+        enabled: (f) => f.dialogue === true,
+        create(d) {
+            const dialogue = createGameDialogue(d.store);
+            d.commandRegistry.define("dialogue.open", {
+                apply(state, input) {
+                    const id = input.id;
+                    if (id !== undefined)
+                        state.game.dialogue?.open(id);
+                },
+            });
+            d.commandRegistry.define("dialogue.close", {
+                apply(state) {
+                    state.game.dialogue?.close();
+                },
+            });
+            return { value: dialogue };
+        },
+    },
+    {
+        key: "players",
+        enabled: (f) => f.players === true,
+        create(d) {
+            return { value: notifyAfter(createConnectedPlayers(), ["join", "leave"], d.signalNotify) };
+        },
+    },
+    {
+        key: "cards",
+        enabled: (f) => f.cards === true,
+        create(d) {
+            return {
+                value: { pile: d.pile },
+                save: {
+                    key: "cards",
+                    snapshot: () => {
+                        const out = {};
+                        for (const [id, cardPile] of d.cardPiles)
+                            out[id] = cardPile.state();
+                        return out;
+                    },
+                    decode: (raw) => decodeRecord(raw),
+                    hydrate: (data) => {
+                        const piles = data;
+                        for (const [id, state] of Object.entries(piles)) {
+                            d.cardPiles.get(id)?.reset(state);
+                        }
+                    },
+                },
+            };
+        },
+    },
+    {
+        key: "turn",
+        enabled: (f) => f.turn === true,
+        create(d) {
+            return {
+                value: { loop: d.loop },
+                save: {
+                    key: "turn",
+                    snapshot: () => {
+                        const out = {};
+                        for (const [id, turnLoop] of d.turnLoops)
+                            out[id] = turnLoop.capture();
+                        return out;
+                    },
+                    decode: (raw) => decodeRecord(raw),
+                    hydrate: (data) => {
+                        const loops = data;
+                        for (const [id, state] of Object.entries(loops)) {
+                            d.turnLoops.get(id)?.restore(state);
+                        }
+                    },
+                },
+            };
+        },
+    },
+    {
+        key: "race",
+        enabled: (f) => f.race === true,
+        create(d) {
+            return { value: { state: d.raceState } };
+        },
+    },
+];

package/dist/runtime/gameContext.d.ts

@@ -1,329 +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";
-import { type HitReaction, type HitReactionConfig } from "../combat/hitReaction.js";
-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";
-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";
-import { type InventoryLayout, type InventorySet } from "../inventory/inventoryModel.js";
-import type { ContextVerb } from "../interaction/contextMenu.js";
-import type { ProximityPrompt } from "../interaction/proximityPrompt.js";
-import { type ItemUseHandler, type ItemUseInput, type ItemUseRejection, type ItemUseResult } from "../item/use.js";
-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 { EntityBlackboard, 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 ConnectedPlayers } from "../game/connectedPlayers.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 WorldSnapshot } from "./worldSnapshot.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>;
-    trade?: TradeField;
-    /** Rarity id read by the `worldItem` loot-filter/render binding when this item drops to the ground (#32/#33). */
-    rarity?: string;
-    /** Base item type read by the loot-filter rule evaluator (#33); defaults to the item id when absent. */
-    baseType?: string;
-}
-export type CatalogEntityRole = "player" | "enemy" | "hostile" | "npc" | "vehicle";
-export interface GameContextEntityEntry {
-    stats?: StatCatalog;
-    receive?: ReceiveMap;
-    onDeath?: OnDeathSpec;
-    movement?: PoseAllowedStates & {
-        walkSpeed?: number;
-    };
-    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;
-    breakable?: false | {
-        baseBreakTime: number;
-    };
-    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;
-    entityById?(catalogId: string): GameContextEntityEntry | null | undefined;
-    objectById?(catalogId: string): GameContextObjectEntry | null | undefined;
-}
-export interface GameContextOptions<TAssetRef extends ModelAssetRef = ModelAssetRef, TMultiplayer = unknown> {
-    definition: GameDefinition<TAssetRef, TMultiplayer>;
-    content: GameContextContent;
-    player: {
-        userId: string;
-        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;
-    position?: [number, number, number];
-    text?: string;
-    kind?: string;
-    amount?: number;
-    hitType?: string;
-    element?: string;
-    crit?: boolean;
-    scale?: number;
-}
-export interface TelegraphInput {
-    from: string;
-    shape: TelegraphShape;
-    at: [number, number, number];
-    dir?: number;
-    windupMs: number;
-    kind?: string;
-    effect?: {
-        effect: string;
-        via?: EffectVia;
-        radius?: number;
-        falloff?: "linear" | "none";
-        los?: boolean;
-    };
-}
-export interface HitReactionInput {
-    from: string;
-    to: string;
-    config: HitReactionConfig;
-    power?: number;
-}
-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;
-    blackboard: EntityBlackboard;
-    stats: EntityStatsApi;
-    floatText(input: FloatTextInput): void;
-    telegraph(input: TelegraphInput): () => void;
-    hitReaction(input: HitReactionInput): HitReaction | null;
-    setTarget(fromId: string, toId: string | null): void;
-    getTarget(fromId: string): string | null;
-    cycleTarget(fromId: string, options?: CycleTargetOptions): string | null;
-    canReceive(instanceId: string, effect: string, magnitude?: number): string | null;
-    preview(input: SingleTargetEffectInput): number;
-    effect(input: EffectInput): EffectResult[];
-    willHitProjectile: ProjectileSystem["willHitProjectile"];
-    fireProjectile: ProjectileSystem["fireProjectile"];
-    settleProjectile: ProjectileSystem["settleProjectile"];
-    distance: SpatialApi["distance"];
-    inRadius: SpatialApi["inRadius"];
-    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";
-    record: WorldItemRecord;
-} | {
-    status: "rejected";
-    reason: string;
-};
-export interface SceneWorldItemContext {
-    spawn(input: WorldItemSpawnInput): WorldItemRecord;
-    get(instanceId: string): WorldItemRecord | null;
-    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;
-    has(name: string): boolean;
-    names(): string[];
-    run(name: string, input: unknown): CommandResult<GameContext>;
-    /** Run a command attributed to `actorUserId` — a shared-world host routes each client's command through this so the handler can read {@link actor}. */
-    runAs(actorUserId: string, name: string, input: unknown): CommandResult<GameContext>;
-    /** The user a command is running on behalf of, or `null` outside a {@link runAs} call — commands default to `ctx.player.userId` when this is `null`. */
-    actor(): string | null;
-}
-export interface GameContextFeed extends Omit<GameFeed, "bind"> {
-    bind(action: keyof GameEventMap): () => void;
-}
-export interface GameContextLoot {
-    register(def: LootTableDef): void;
-    has(id: string): boolean;
-    roll(id: string, rng?: () => number): Drop[];
-    grantToPlayer(userId: string, drops: Drop[], source?: string): void;
-}
-export interface GameContextEconomy {
-    balance(userId: string, currencyId: string): number;
-    grant(userId: string, currencyId: string, amount: number): void;
-    charge(userId: string, currencyId: string, amount: number): {
-        reason: string;
-    } | null;
-}
-export interface GameContextItemUse {
-    register(handlers: Record<string, ItemUseHandler<GameContext>>): void;
-    registered(): string[];
-    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;
-}
-/** Reachable audio seam on `ctx.game`: `play`, `music`, and `resume` route through the `audio.play`/`audio.music`/`audio.resume` events the shell's audio engine listens on, so game code triggers sound without importing the shell. */
-export interface GameAudio {
-    play(sound: string, at?: readonly [number, number, number]): void;
-    /** Crossfade the procedural soundtrack to `theme` (null fades out); `transpose` shifts the incoming theme's key in semitones. */
-    music(theme: string | null, transpose?: number): void;
-    resume(): void;
-}
-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;
-        audio: GameAudio;
-        /** Play a model's one-shot animation clip bound to `event` in its `animation.oneShots` (e.g. an attack swing) — emits `entity.animation` for the shell to pick up. */
-        playEntityAnimation(instanceId: string, event: string): void;
-        feed: GameContextFeed;
-        loot: GameContextLoot;
-        trade: TradeSystem;
-        quest: QuestJournal;
-        /** Friends/party/presence/emotes/world-invites — present only when `features.social` is set. */
-        social?: Social;
-        /** Channels + messages — present only when `features.chat` is set (implies `social`). */
-        chat?: Chat;
-        unlocks: Unlocks;
-        economy: GameContextEconomy;
-        /** Competitive score tracking — present only when `features.leaderboard` is set. */
-        leaderboard?: Leaderboard;
-        /** Owned-entity roster — present only when `features.roster` is set. */
-        roster?: Roster;
-        /** Game-defined keyed reactive store slot (#163.1); mutations bump `ctx.version()`/notify `ctx.subscribe`. */
-        store: ObservableKeyedStore<unknown>;
-        /** Card pile zones — present only when `features.cards` is set. */
-        cards?: GameContextCards;
-        /** Turn/phase loop — present only when `features.turn` is set. */
-        turn?: GameContextTurn;
-        /** Lap/checkpoint race state — present only when `features.race` is set. */
-        race?: GameContextRace;
-        /** Connected-player set for a shared world — present only when `features.players` is set. */
-        players?: ConnectedPlayers;
-    };
-    player: {
-        /** The acting player's id — the command actor inside `runAs`, the local player everywhere else. */
-        userId: string;
-        isNew: boolean;
-        /** The acting player's inventory set — the command actor's bags inside `runAs`, the local player's everywhere else. */
-        inventory: InventorySet<string>;
-        /** A specific player's inventory set — how a host reads or grants into any connected player's bags. */
-        inventoryFor(userId: string): InventorySet<string>;
-        /** The acting player's stat modifiers — the command actor's inside `runAs`, the local player's everywhere else. */
-        stats: Stats<string>;
-        /** A specific player's stat modifiers — how a host reads or buffs any connected player's stats. */
-        statsFor(userId: string): Stats<string>;
-        loadout: Loadouts;
-        applyLoadout(userId: string, loadoutId: string): {
-            reason: string;
-        } | null;
-        movement: PoseState;
-        possession: Possession;
-        cosmetics: Cosmetics;
-        /** Motion seam into the movement integrator (#162.4); routes to the command actor's queue (or the local player outside a command), so a command's impulse lands on whoever ran it. See `MotionIntents`. */
-        motion: MotionIntents;
-        /** A specific player's motion queue — how the host-side per-player movement integrator drains each connected player's impulses. */
-        motionFor(userId: string): 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;
-    /**
-     * Gather every opted-in live subsystem into one {@link WorldSnapshot} — entities, entity stats, the
-     * keyed store, the action feed, plus leaderboard/chat when those features are on. The full-world
-     * baseline a host sends a joining client; {@link hydrate} is its inverse.
-     */
-    snapshot(): WorldSnapshot;
-    /** Apply a {@link WorldSnapshot} from an authoritative host, hydrating each subsystem key present in it. */
-    hydrate(snapshot: WorldSnapshot): void;
-}
+import type { GameContext, GameContextOptions } from "./gameContextTypes.js";
+export type { CatalogEntityRole, FloatTextInput, GameAudio, GameContext, GameContextCards, GameContextCommands, GameContextContent, GameContextEconomy, GameContextEntityEntry, GameContextFeed, GameContextItemEntry, GameContextItemUse, GameContextLoot, GameContextModels, GameContextObjectEntry, GameContextOptions, GameContextRace, GameContextTurn, GameContextWorld, HitReactionInput, MoveTowardCommitOptions, SceneEntityContext, SceneObjectContext, SceneWorldItemContext, TelegraphInput, VfxInput, WorldItemPickupResult, } from "./gameContextTypes.js";
 export declare function createGameContext<TAssetRef extends ModelAssetRef, TMultiplayer>(options: GameContextOptions<TAssetRef, TMultiplayer>): GameContext;