@jgengine/core 0.14.0 → 0.15.0

package/dist/game/talentTreeView.d.ts

@@ -0,0 +1,106 @@
+import type { TalentNodeDef, TalentTree } from "./talents.js";
+/**
+ * Render state of a talent node, derived from its rank and prerequisite satisfaction.
+ * - `locked` — rank 0 and at least one prerequisite unmet; cannot be trained yet.
+ * - `available` — rank 0, every prerequisite met; ready to take a first point.
+ * - `learned` — at least one rank invested, but below `maxRank`.
+ * - `maxed` — fully invested (`rank === maxRank`).
+ */
+export type TalentNodeState = "locked" | "available" | "learned" | "maxed";
+/** One prerequisite edge into a node — the source node, the rank it demands, and whether that is met. */
+export interface TalentEdgeView {
+    /** Prerequisite node id (edge source). */
+    from: string;
+    /** Rank the prerequisite must reach for this edge to be satisfied. */
+    rank: number;
+    /** Whether the prerequisite currently sits at or above the required rank. */
+    met: boolean;
+}
+/** A per-node view for rendering: grid placement (tier/branch), rank, state, and inbound prerequisite edges. */
+export interface TalentNodeView {
+    /** Stable node id (matches the {@link TalentNodeDef}). */
+    id: string;
+    /** Branch key the node belongs to (`""` when the def has none) — a free string the game styles/columns by. */
+    branch: string;
+    /** 0-based prerequisite depth: `0` for a root, else `1 + max(tier of prerequisites)`. Drives row/tier layout. */
+    tier: number;
+    /** Points currently invested in the node. */
+    rank: number;
+    /** Maximum points the node accepts. */
+    maxRank: number;
+    /** Derived render state (see {@link TalentNodeState}). */
+    state: TalentNodeState;
+    /** Whether a point can be spent on the node right now (mirrors `tree.canAllocate(id).ok`). */
+    allocatable: boolean;
+    /** Inbound prerequisite edges, in definition order. */
+    requires: readonly TalentEdgeView[];
+}
+/** A whole-tree render view: placed nodes plus branch/tier extents and point totals. */
+export interface TalentTreeView {
+    /** Every node, in definition order, with its render placement and state. */
+    nodes: readonly TalentNodeView[];
+    /** Distinct branch keys, in first-seen (definition) order — the natural column order. */
+    branches: readonly string[];
+    /** Number of tiers, i.e. `max(tier) + 1` (0 when the tree is empty). */
+    tiers: number;
+    /** Points the player still has to spend. */
+    pointsAvailable: number;
+    /** Points already invested across the tree. */
+    pointsSpent: number;
+}
+/**
+ * Per-node status a game supplies to build a view from *any* unlock rule — not just point-spend.
+ * A game computes these from whatever it wants (a currency threshold, a level, a quest flag, a
+ * skill-point pool, nothing at all) so the same widget renders a buy-with-points talent tree, a
+ * money-gated upgrade tree, or a condition-unlocked ability web without changing the renderer.
+ */
+export interface TalentNodeStatus {
+    /** Points/levels invested in the node — `0` means "not taken yet"; a binary unlock uses `0`/`1`. */
+    rank: number;
+    /**
+     * Whether the node can be taken right now under the game's own rule (enough points, enough cash,
+     * a level reached, a flag set, …). Drives the `available` state and whether the widget fires
+     * `onLearn` for it. The view never interprets *why* — that stays the game's decision.
+     */
+    allocatable: boolean;
+}
+/** Optional overall point totals for the view header; omit (or 0) for trees that spend no point currency. */
+export interface TalentPointTotals {
+    /** Points the player still has to spend. Default `0`. */
+    pointsAvailable?: number;
+    /** Points already invested across the tree. Default `0`. */
+    pointsSpent?: number;
+}
+/**
+ * Build a flat, serializable render view of a node graph from a caller-supplied per-node status,
+ * decoupled from any particular progression model. For each node the game returns its `rank` and
+ * whether it is `allocatable` *right now* under whatever rule it likes — a skill-point pool, a cash
+ * threshold, a level gate, a quest flag, or nothing. The builder places every node by branch +
+ * prerequisite-depth tier, tags it learned/available/locked/maxed (`available` when rank 0 and every
+ * prerequisite is met — see below), and resolves inbound prerequisite edges (each `met` when the
+ * source node's supplied rank meets the demand). This is the general escape hatch behind
+ * {@link talentTreeView}: it lets the same widget render a buy-with-points talent tree, a money-gated
+ * upgrade tree, or a condition-unlocked ability web without the renderer changing. It never interprets
+ * what a node *means* — ids, branches, and ranks stay opaque game data.
+ *
+ * `state` is derived purely from the supplied `rank` vs `maxRank` and prerequisite satisfaction, so a
+ * node the game considers takeable-by-condition surfaces as `available` (rank 0, prerequisites met)
+ * and the widget only fires `onLearn` for nodes whose `allocatable` the game returned `true`.
+ *
+ * @capability talent-tree-view-from build a placed talent/upgrade-tree render view from any per-node unlock rule (points, currency, level, flag) — branch/tier layout, learned/available/locked/maxed state, prerequisite edges
+ */
+export declare function talentTreeViewFrom<TStat extends string = string>(nodes: readonly TalentNodeDef<TStat>[], status: (node: TalentNodeDef<TStat>) => TalentNodeStatus, totals?: TalentPointTotals): TalentTreeView;
+/**
+ * Project the existing talent model (`createTalentTree`) into a flat, serializable render view: every
+ * node placed by branch + prerequisite-depth tier, tagged learned/available/locked/maxed, with its
+ * inbound prerequisite edges (and whether each is met) and whether a point can be spent right now. It is
+ * a pure read over the node defs plus a live {@link TalentTree}, so a React/canvas widget can lay out
+ * nodes, draw edges, and gate clicks without re-deriving topology or re-interpreting eligibility. The
+ * model still owns allocation, requirements, and point rules — this only reshapes them for drawing, and
+ * never interprets what a node *means* (ids, branches, and ranks stay opaque game data). This is the
+ * point-spend adapter over {@link talentTreeViewFrom}; pass a custom status to that builder instead to
+ * drive the tree from a currency, level, or any other unlock rule.
+ *
+ * @capability talent-tree-view flatten a talent tree into a placed, per-node render view — branch/tier layout, learned/available/locked/maxed state, prerequisite edges
+ */
+export declare function talentTreeView<TStat extends string = string>(nodes: readonly TalentNodeDef<TStat>[], tree: TalentTree<TStat>): TalentTreeView;

package/dist/game/talentTreeView.js

@@ -0,0 +1,114 @@
+const DEFAULT_BRANCH = "";
+function requirementNode(requirement) {
+    return typeof requirement === "string" ? requirement : requirement.nodeId;
+}
+function requirementRank(requirement) {
+    return typeof requirement === "string" ? 1 : requirement.rank;
+}
+/**
+ * Compute each node's tier as its longest prerequisite chain depth, memoized. Cycles and
+ * dangling prerequisite ids are treated as tier `0` contributions so the pass always terminates.
+ */
+function computeTiers(byId) {
+    const tiers = new Map();
+    const visiting = new Set();
+    function tierOf(id) {
+        const cached = tiers.get(id);
+        if (cached !== undefined)
+            return cached;
+        const node = byId.get(id);
+        if (node === undefined || visiting.has(id))
+            return 0;
+        visiting.add(id);
+        let depth = 0;
+        for (const requirement of node.requires ?? []) {
+            const reqId = requirementNode(requirement);
+            if (byId.has(reqId))
+                depth = Math.max(depth, tierOf(reqId) + 1);
+        }
+        visiting.delete(id);
+        tiers.set(id, depth);
+        return depth;
+    }
+    for (const id of byId.keys())
+        tierOf(id);
+    return tiers;
+}
+/**
+ * Build a flat, serializable render view of a node graph from a caller-supplied per-node status,
+ * decoupled from any particular progression model. For each node the game returns its `rank` and
+ * whether it is `allocatable` *right now* under whatever rule it likes — a skill-point pool, a cash
+ * threshold, a level gate, a quest flag, or nothing. The builder places every node by branch +
+ * prerequisite-depth tier, tags it learned/available/locked/maxed (`available` when rank 0 and every
+ * prerequisite is met — see below), and resolves inbound prerequisite edges (each `met` when the
+ * source node's supplied rank meets the demand). This is the general escape hatch behind
+ * {@link talentTreeView}: it lets the same widget render a buy-with-points talent tree, a money-gated
+ * upgrade tree, or a condition-unlocked ability web without the renderer changing. It never interprets
+ * what a node *means* — ids, branches, and ranks stay opaque game data.
+ *
+ * `state` is derived purely from the supplied `rank` vs `maxRank` and prerequisite satisfaction, so a
+ * node the game considers takeable-by-condition surfaces as `available` (rank 0, prerequisites met)
+ * and the widget only fires `onLearn` for nodes whose `allocatable` the game returned `true`.
+ *
+ * @capability talent-tree-view-from build a placed talent/upgrade-tree render view from any per-node unlock rule (points, currency, level, flag) — branch/tier layout, learned/available/locked/maxed state, prerequisite edges
+ */
+export function talentTreeViewFrom(nodes, status, totals) {
+    const byId = new Map();
+    for (const node of nodes)
+        byId.set(node.id, node);
+    const tiers = computeTiers(byId);
+    // Resolve every node's status once up front so prerequisite `met` checks can read a sibling's rank.
+    const statusById = new Map();
+    for (const node of nodes)
+        statusById.set(node.id, status(node));
+    const branches = [];
+    const seenBranches = new Set();
+    let maxTier = -1;
+    const viewNodes = nodes.map((node) => {
+        const branch = node.branch ?? DEFAULT_BRANCH;
+        if (!seenBranches.has(branch)) {
+            seenBranches.add(branch);
+            branches.push(branch);
+        }
+        const tier = tiers.get(node.id) ?? 0;
+        if (tier > maxTier)
+            maxTier = tier;
+        const { rank, allocatable } = statusById.get(node.id);
+        const requires = (node.requires ?? []).map((requirement) => {
+            const from = requirementNode(requirement);
+            const required = requirementRank(requirement);
+            return { from, rank: required, met: (statusById.get(from)?.rank ?? 0) >= required };
+        });
+        let state;
+        if (rank >= node.maxRank)
+            state = "maxed";
+        else if (rank > 0)
+            state = "learned";
+        else
+            state = requires.every((edge) => edge.met) ? "available" : "locked";
+        return { id: node.id, branch, tier, rank, maxRank: node.maxRank, state, allocatable, requires };
+    });
+    return {
+        nodes: viewNodes,
+        branches,
+        tiers: maxTier + 1,
+        pointsAvailable: totals?.pointsAvailable ?? 0,
+        pointsSpent: totals?.pointsSpent ?? 0,
+    };
+}
+/**
+ * Project the existing talent model (`createTalentTree`) into a flat, serializable render view: every
+ * node placed by branch + prerequisite-depth tier, tagged learned/available/locked/maxed, with its
+ * inbound prerequisite edges (and whether each is met) and whether a point can be spent right now. It is
+ * a pure read over the node defs plus a live {@link TalentTree}, so a React/canvas widget can lay out
+ * nodes, draw edges, and gate clicks without re-deriving topology or re-interpreting eligibility. The
+ * model still owns allocation, requirements, and point rules — this only reshapes them for drawing, and
+ * never interprets what a node *means* (ids, branches, and ranks stay opaque game data). This is the
+ * point-spend adapter over {@link talentTreeViewFrom}; pass a custom status to that builder instead to
+ * drive the tree from a currency, level, or any other unlock rule.
+ *
+ * @capability talent-tree-view flatten a talent tree into a placed, per-node render view — branch/tier layout, learned/available/locked/maxed state, prerequisite edges
+ */
+export function talentTreeView(nodes, tree) {
+    return talentTreeViewFrom(nodes, (node) => ({ rank: tree.rank(node.id), allocatable: tree.canAllocate(node.id).ok }), { pointsAvailable: tree.pointsAvailable(), pointsSpent: tree.pointsSpent() });
+}

package/dist/game/worldItem.js

@@ -1,5 +1,6 @@
 import { distanceBetween } from "../scene/spatial.js";
 import { evaluateLootFilter } from "./lootFilter.js";
+import { resolveRng } from "../random/resolveRng.js";
 /** Scene-entity catalog name every dropped-item instance spawns under (see the three buckets: worldItem is an entity, never an inventory item or object). */
 export const WORLD_ITEM_ENTITY_NAME = "world_item";
 export const DEFAULT_RARITY = "common";
@@ -105,7 +106,7 @@ export function createWorldItemStore(deps) {
 export function resolveDeathDrops(drops, options) {
     if (options.mode !== "world")
         return { worldSpawns: [], grants: [...drops] };
-    const rng = options.rng ?? Math.random;
+    const rng = resolveRng(options.rng, "worldItem");
     const worldSpawns = [];
     const grants = [];
     for (const drop of drops) {

package/dist/gameplay.d.ts

@@ -9,40 +9,49 @@ export { createAuctionBook, type Auction, type AuctionSettlement } from "./econo
 export { createListingBook, type Listing } from "./economy/listingBook.js";
 export { createPriceHistory, type PriceStats, type SaleRecord } from "./economy/priceHistory.js";
 export { addScheduledRule, advanceLedger, annotate, balanceOf, cancelRule, capAmount, createResourceLedger, curveScale, pauseRule, redirect, rejectWhen, resumeRule, taxFraction, thresholdScale, type AdvanceOptions, type AdvanceResult, type AppliedTransaction, type CatchUpPolicy, type LedgerEvent, type LedgerEventKind, type PolicyContext, type PolicyRead, type Precision, type ResourceLedger, type ResourcePolicy, type ResourceTransaction, type RuleCursor, type ScheduledRule, type ThresholdBand, } from "./economy/resourceLedger.js";
+export { createShopStock, type ShopBuyRejection, type ShopBuyResult, type ShopPrice, type ShopSellRejection, type ShopSellResult, type ShopStock, type ShopStockConfig, type ShopStockEntry, type ShopStockSnapshot, } from "./economy/shopStock.js";
 export { type TechNodeDef } from "./economy/techTree.js";
-export { balance, charge, chargeAll, createEmptyWallet, grant, isOverdrawn } from "./economy/wallet.js";
+export { balance, canAfford, charge, chargeAll, createEmptyWallet, grant, isOverdrawn, type ChargeOptions, type ChargeResult, type Overdraft, } from "./economy/wallet.js";
+export { createAchievementTracker, type AchievementDef, type AchievementSnapshot, type AchievementTracker, type AchievementTrackerOptions, type AchievementUnlock, type AchievementView, } from "./game/achievements.js";
 export { DEFAULT_CHAT_BODY_LENGTH, DEFAULT_CHAT_HISTORY_LIMIT, DEFAULT_CHAT_RATE_LIMIT, createChatRateLimiter, type Chat, type ChatMessage, type ChatRateLimit, type ChatSendResult, } from "./game/chat.js";
+export { createCodex, type Codex, type CodexEntryDef, type CodexEntryView, type CodexOptions, type CodexSnapshot, } from "./game/codex.js";
 export { playControlsActive } from "./game/controlGate.js";
 export { createCosmetics } from "./game/cosmetics.js";
-export { type GameDefinition, type GameDefinitionConfig, type GameLoop, type InventoryDeclaration, type LifecycleConfig, type PhysicsConfig, } from "./game/defineGame.js";
+export { type GameDefinition, type GameDefinitionConfig, type GameLifecycle, type GameLoop, type InventoryDeclaration, type LifecycleConfig, type PhysicsConfig, } from "./game/defineGame.js";
 export { defineSystem, type SystemDefinition, type SystemEventHandlers, type SystemTick } from "./game/defineSystem.js";
 export { createGameDialogue, dialogueSlot } from "./game/dialogue.js";
+export { createDialogueRun, selectDialogueView, type DialogueGraph, type DialogueGraphChoice, type DialogueGraphNode, type DialogueGraphSnapshot, type DialogueGraphView, type DialogueRun, type DialogueRunOptions, } from "./game/dialogueGraph.js";
+export { createEventTicker, type EventTicker, type EventTickerEntry, type EventTickerInput, type EventTickerOptions, type EventTickerSnapshot, type EventTickerView, } from "./game/eventTicker.js";
 export { createGameEvents, type CombatTelegraphEvent, type CombatVfxEvent, type EntityDiedEvent, type EntityFloatTextEvent, type GameEventMap, type GameEvents, type RetainedVfxKind, type StatLevelUpEvent, type VfxKind, type VfxRef, } from "./game/events.js";
 export { appendFeed, createGameFeed, pruneFeed, type FeedEntry, type FeedWindow, type TimedFeedEntry, } from "./game/feed.js";
 export { gamePhase, setGamePhase, type GamePhase } from "./game/gamePhase.js";
 export { createKeyValueStore, type KeyValueStorage } from "./game/keyValueStore.js";
 export { createLeaderboard, type LeaderboardRow, type LeaderboardScope } from "./game/leaderboard.js";
+export { medalFor, rankLeaderboard, type RankLeaderboardOptions, type RankableRow, type RankedEntry, type TieMode, } from "./game/leaderboardRank.js";
 export { createLevelSequence, type LevelSequence } from "./game/levelSequence.js";
 export { createLoadouts, type LoadoutDef } from "./game/loadout.js";
 export { evaluateLootFilter, lootFilter, type LootFilterRule } from "./game/lootFilter.js";
 export { createLootPipeline, defineLootPipeline, type LootDropProvenance, type LootModifier, type LootPipeline, type LootPipelineDef, type LootPipelineDeps, type LootPlanEntry, type LootResolution, type LootResolveContext, type LootRollPlan, type LootStage, type LootStageKind, type LootStageStatus, type LootStageTrace, } from "./game/lootPipeline.js";
 export { createLootRegistry, lootTable, type Drop, type LootTableDef } from "./game/lootTable.js";
 export { resolveOneShotClip } from "./game/modelAnimation.js";
+export { createNotificationCenter, type NotificationCenterOptions, type NotificationEntry, type NotificationFilter, type NotificationInput, type NotificationStore, } from "./game/notifications.js";
 export { evaluateObjective } from "./game/objectives.js";
 export { createLayerRegistry, diffParams, orderLayers, resolveParams, resolveSelection, validateLayers, type LayerConflict, type LayerOps, type LayerRegistry, type LayerSelection, type ParamContribution, type ParamDelta, type ParamLayer, type ParamOp, type ParamSnapshot, } from "./game/paramLayers.js";
 export { DEFAULT_PING_CATEGORIES, PING_FEED_ACTION, createPingSystem, type PingCategory, type PingSystem, } from "./game/ping.js";
 export { CAMERA_FRUSTUM_DEFAULTS, worldHealthBarAllowsRole, type BackdropConfig, type CameraKeyframe, type CameraRigKind, type ChaseCameraConfig, type CinematicCameraConfig, type DirectionalLightingConfig, type EntitySpriteConfig, type FirstPersonCameraConfig, type GameCameraConfig, type InspectionCameraConfig, type InspectionZoomAnchor, type LightingConfig, type LockOnCameraConfig, type ModelConfig, type ModelMaterialMaps, type ModelMaterialOverride, type ObjectStyle, type ObserverCameraConfig, type PlayableGame, type PointerConfig, type RtsCameraConfig, type ShoulderCameraConfig, type SideScrollCameraConfig, type TopDownCameraConfig, type WorldItemRenderConfig, type WorldOverlayProps, } from "./game/playableGame.js";
 export { curve, evalCurve, leveling, type Curve, type LevelProgress, type LevelingConfig, type LevelingTrack, } from "./game/progression.js";
-export { createQuestJournal, type QuestDef, type QuestInstance, type QuestRewards } from "./game/quest.js";
+export { createQuestJournal, defaultObjectiveLabel, describeTrackedQuest, type QuestDef, type QuestInstance, type QuestRewards, type TrackedObjectiveView, type TrackedQuestView, } from "./game/quest.js";
 export { RaceState, createLapTimer, createRaceState, finishRaceSession, firstPastPost, idleRaceSession, lapDurations, parDelta, placementOf, raceOutcomeOf, racePlacements, raceTrack, splitSegments, startRaceCountdown, tickRaceSession, } from "./game/race.js";
 export { createRecordBook } from "./game/recordBook.js";
 export { createRuleRegistry, rerollRules, selectRules, type RuleDef, type RuleRegistry, type RuleSelection, type RuleSelectionConfig, } from "./game/ruleSelection.js";
 export { createRunDraft, type RunDraft, type RunModifierOffer } from "./game/runDraft.js";
+export { createSaveSlots, type SaveSlotMeta, type SaveSlotWrite, type SaveSlots, type SaveSlotsConfig, type SaveSlotsSnapshot, } from "./game/saveSlots.js";
 export { createSaveStore, localSaveBackend, memorySaveBackend, remoteSaveBackend, type SaveBackend, type SaveStatus, type SaveStore, } from "./game/saveStore.js";
 export { createSocial, type FriendEntry, type FriendRequestEntry, type Friends, type Party, type PartyInviteEntry, type PartyMemberEntry, type PresenceInfo, type Social, type SocialDeps, type WorldInvite, type WorldInviteTarget, } from "./game/social.js";
 export { createSpawnPoints } from "./game/spawnPoints.js";
 export { composeGameLoop } from "./game/systemRuntime.js";
 export { DEFAULT_FIXED_STAGES, DEFAULT_FRAME_STAGES, compileSystemSchedule, type CompiledSystemSchedule, } from "./game/systemSchedule.js";
+export { talentTreeView, talentTreeViewFrom, type TalentEdgeView, type TalentNodeState, type TalentNodeStatus, type TalentNodeView, type TalentPointTotals, type TalentTreeView, } from "./game/talentTreeView.js";
 export { createTalentTree, type TalentNodeDef, type TalentTree } from "./game/talents.js";
 export { appendToast, createToastQueue, pruneToasts, type Toast } from "./game/toasts.js";
 export { createUnlockCatalog, createUnlocks, type UnlockDef } from "./game/unlocks.js";
@@ -54,8 +63,10 @@ export { applyBindingOverrides, clearBindingOverride, loadBindingOverrides, save
 export { createGestureSurfaceTracker } from "./input/gestureSurface.js";
 export { aimToPoint, type PointerHit, type PointerVec3 } from "./input/pointer.js";
 export { normalizePointerToAxis, type PointerAxisState } from "./input/pointerAxis.js";
+export { createRebindSession, type RebindActionConfig, type RebindConflict, type RebindRow, type RebindSession, type RebindSessionActionsConfig, type RebindSessionConfig, type RebindSessionMapConfig, type RebindSessionSnapshot, } from "./input/rebindSession.js";
+export { activeTouchControlsMode, setTouchControlsMode } from "./input/touchControlsMode.js";
 export { createTouchGestureTracker } from "./input/touchGestures.js";
-export { DEFAULT_TOUCH_STYLE, TOUCH_STYLES, TOUCH_STYLE_OPTIONS, deriveTouchScheme, touchButtonShape, touchCode, withTouchCodes, type TouchAnchor, type TouchButton, type TouchButtonShape, type TouchJoystick, type TouchScheme, type TouchStyle, } from "./input/touchScheme.js";
+export { DEFAULT_TOUCH_STYLE, TOUCH_STYLES, TOUCH_STYLE_OPTIONS, deriveTouchScheme, touchButtonShape, touchCode, withTouchCodes, type TouchAnchor, type TouchButton, type TouchButtonShape, type TouchControlsConfig, type TouchControlsModeConfig, type TouchJoystick, type TouchScheme, type TouchStyle, } from "./input/touchScheme.js";
 export { type InventorySlot, type InventoryState } from "./inventory/inventoryModel.js";
 export { type Cell, type Rotation } from "./inventory/shapedGrid.js";
 export { type SlotGrid } from "./inventory/slotModel.js";

package/dist/gameplay.js

@@ -9,40 +9,49 @@ export { createAuctionBook } from "./economy/auctionBook.js";
 export { createListingBook } from "./economy/listingBook.js";
 export { createPriceHistory } from "./economy/priceHistory.js";
 export { addScheduledRule, advanceLedger, annotate, balanceOf, cancelRule, capAmount, createResourceLedger, curveScale, pauseRule, redirect, rejectWhen, resumeRule, taxFraction, thresholdScale, } from "./economy/resourceLedger.js";
+export { createShopStock, } from "./economy/shopStock.js";
 export {} from "./economy/techTree.js";
-export { balance, charge, chargeAll, createEmptyWallet, grant, isOverdrawn } from "./economy/wallet.js";
+export { balance, canAfford, charge, chargeAll, createEmptyWallet, grant, isOverdrawn, } from "./economy/wallet.js";
+export { createAchievementTracker, } from "./game/achievements.js";
 export { DEFAULT_CHAT_BODY_LENGTH, DEFAULT_CHAT_HISTORY_LIMIT, DEFAULT_CHAT_RATE_LIMIT, createChatRateLimiter, } from "./game/chat.js";
+export { createCodex, } from "./game/codex.js";
 export { playControlsActive } from "./game/controlGate.js";
 export { createCosmetics } from "./game/cosmetics.js";
 export {} from "./game/defineGame.js";
 export { defineSystem } from "./game/defineSystem.js";
 export { createGameDialogue, dialogueSlot } from "./game/dialogue.js";
+export { createDialogueRun, selectDialogueView, } from "./game/dialogueGraph.js";
+export { createEventTicker, } from "./game/eventTicker.js";
 export { createGameEvents, } from "./game/events.js";
 export { appendFeed, createGameFeed, pruneFeed, } from "./game/feed.js";
 export { gamePhase, setGamePhase } from "./game/gamePhase.js";
 export { createKeyValueStore } from "./game/keyValueStore.js";
 export { createLeaderboard } from "./game/leaderboard.js";
+export { medalFor, rankLeaderboard, } from "./game/leaderboardRank.js";
 export { createLevelSequence } from "./game/levelSequence.js";
 export { createLoadouts } from "./game/loadout.js";
 export { evaluateLootFilter, lootFilter } from "./game/lootFilter.js";
 export { createLootPipeline, defineLootPipeline, } from "./game/lootPipeline.js";
 export { createLootRegistry, lootTable } from "./game/lootTable.js";
 export { resolveOneShotClip } from "./game/modelAnimation.js";
+export { createNotificationCenter, } from "./game/notifications.js";
 export { evaluateObjective } from "./game/objectives.js";
 export { createLayerRegistry, diffParams, orderLayers, resolveParams, resolveSelection, validateLayers, } from "./game/paramLayers.js";
 export { DEFAULT_PING_CATEGORIES, PING_FEED_ACTION, createPingSystem, } from "./game/ping.js";
 export { CAMERA_FRUSTUM_DEFAULTS, worldHealthBarAllowsRole, } from "./game/playableGame.js";
 export { curve, evalCurve, leveling, } from "./game/progression.js";
-export { createQuestJournal } from "./game/quest.js";
+export { createQuestJournal, defaultObjectiveLabel, describeTrackedQuest, } from "./game/quest.js";
 export { RaceState, createLapTimer, createRaceState, finishRaceSession, firstPastPost, idleRaceSession, lapDurations, parDelta, placementOf, raceOutcomeOf, racePlacements, raceTrack, splitSegments, startRaceCountdown, tickRaceSession, } from "./game/race.js";
 export { createRecordBook } from "./game/recordBook.js";
 export { createRuleRegistry, rerollRules, selectRules, } from "./game/ruleSelection.js";
 export { createRunDraft } from "./game/runDraft.js";
+export { createSaveSlots, } from "./game/saveSlots.js";
 export { createSaveStore, localSaveBackend, memorySaveBackend, remoteSaveBackend, } from "./game/saveStore.js";
 export { createSocial, } from "./game/social.js";
 export { createSpawnPoints } from "./game/spawnPoints.js";
 export { composeGameLoop } from "./game/systemRuntime.js";
 export { DEFAULT_FIXED_STAGES, DEFAULT_FRAME_STAGES, compileSystemSchedule, } from "./game/systemSchedule.js";
+export { talentTreeView, talentTreeViewFrom, } from "./game/talentTreeView.js";
 export { createTalentTree } from "./game/talents.js";
 export { appendToast, createToastQueue, pruneToasts } from "./game/toasts.js";
 export { createUnlockCatalog, createUnlocks } from "./game/unlocks.js";
@@ -54,6 +63,8 @@ export { applyBindingOverrides, clearBindingOverride, loadBindingOverrides, save
 export { createGestureSurfaceTracker } from "./input/gestureSurface.js";
 export { aimToPoint } from "./input/pointer.js";
 export { normalizePointerToAxis } from "./input/pointerAxis.js";
+export { createRebindSession, } from "./input/rebindSession.js";
+export { activeTouchControlsMode, setTouchControlsMode } from "./input/touchControlsMode.js";
 export { createTouchGestureTracker } from "./input/touchGestures.js";
 export { DEFAULT_TOUCH_STYLE, TOUCH_STYLES, TOUCH_STYLE_OPTIONS, deriveTouchScheme, touchButtonShape, touchCode, withTouchCodes, } from "./input/touchScheme.js";
 export {} from "./inventory/inventoryModel.js";

package/dist/i18n/i18n.d.ts

@@ -0,0 +1,51 @@
+/** A locale tag (e.g. `"en"`, `"es"`, `"ja"`) — a key into a {@link Catalog}. */
+export type Locale = string;
+/** Flat message table for one locale: key → template string with `{param}` slots. */
+export type Messages = Readonly<Record<string, string>>;
+/** All locales' message tables, keyed by locale. */
+export type Catalog = Readonly<Record<Locale, Messages>>;
+/** Interpolation values for a message template. */
+export type TParams = Readonly<Record<string, string | number>>;
+/**
+ * Replace `{name}` placeholders in `template` with `params[name]`. Unknown
+ * placeholders are left intact. Pure and locale-independent.
+ */
+export declare function interpolate(template: string, params?: TParams): string;
+/** Configuration for {@link createI18n}. */
+export interface I18nOptions {
+    catalog: Catalog;
+    /** Active locale. Must be a key of `catalog` for lookups to resolve there. */
+    locale: Locale;
+    /** Locale consulted when a key is missing in the active locale. */
+    fallbackLocale?: Locale;
+    /** Invoked when a key resolves nowhere (dev warnings/telemetry); `t` still returns the key. */
+    onMissing?: (key: string, locale: Locale) => void;
+}
+/** Runtime translator over a message {@link Catalog} — active locale, lookup with fallback, interpolation, and pluralization. */
+export interface I18n {
+    locale(): Locale;
+    /** Switch the active locale; notifies subscribers when it actually changes. */
+    setLocale(locale: Locale): void;
+    /** Locales present in the catalog. */
+    locales(): readonly Locale[];
+    /** True when `key` resolves in the active or fallback locale. */
+    has(key: string): boolean;
+    /** Translate `key`, interpolating `{param}` slots; returns `key` itself if it resolves nowhere. */
+    t(key: string, params?: TParams): string;
+    /**
+     * Plural-aware translate: picks `${key}.${category}` for the active locale's
+     * Intl plural category (falling back to `${key}.other`, then `key`), with
+     * `count` available as the `{count}` interpolation param.
+     */
+    plural(key: string, count: number, params?: TParams): string;
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * Create a translator over a message catalog: active-locale lookup with a
+ * fallback-locale chain, `{param}` interpolation, and `Intl.PluralRules`-based
+ * pluralization. Observable (`subscribe`) so React re-renders on `setLocale`;
+ * the catalog is caller-owned static data, the locale is the only state.
+ *
+ * @capability i18n translate a message catalog with fallback-locale lookup, `{param}` interpolation, and Intl pluralization; observable active-locale switching
+ */
+export declare function createI18n(options: I18nOptions): I18n;

package/dist/i18n/i18n.js

@@ -0,0 +1,82 @@
+/**
+ * Replace `{name}` placeholders in `template` with `params[name]`. Unknown
+ * placeholders are left intact. Pure and locale-independent.
+ */
+export function interpolate(template, params) {
+    if (params === undefined)
+        return template;
+    return template.replace(/\{(\w+)\}/g, (whole, name) => {
+        const value = params[name];
+        return value === undefined ? whole : String(value);
+    });
+}
+function pluralCategory(locale, count) {
+    try {
+        return new Intl.PluralRules(locale).select(count);
+    }
+    catch {
+        return count === 1 ? "one" : "other";
+    }
+}
+/**
+ * Create a translator over a message catalog: active-locale lookup with a
+ * fallback-locale chain, `{param}` interpolation, and `Intl.PluralRules`-based
+ * pluralization. Observable (`subscribe`) so React re-renders on `setLocale`;
+ * the catalog is caller-owned static data, the locale is the only state.
+ *
+ * @capability i18n translate a message catalog with fallback-locale lookup, `{param}` interpolation, and Intl pluralization; observable active-locale switching
+ */
+export function createI18n(options) {
+    const { catalog, fallbackLocale, onMissing } = options;
+    let active = options.locale;
+    const listeners = new Set();
+    function resolve(key) {
+        const inActive = catalog[active]?.[key];
+        if (inActive !== undefined)
+            return inActive;
+        if (fallbackLocale !== undefined && fallbackLocale !== active)
+            return catalog[fallbackLocale]?.[key];
+        return undefined;
+    }
+    const i18n = {
+        locale() {
+            return active;
+        },
+        setLocale(locale) {
+            if (locale === active)
+                return;
+            active = locale;
+            for (const listener of listeners)
+                listener();
+        },
+        locales() {
+            return Object.keys(catalog);
+        },
+        has(key) {
+            return resolve(key) !== undefined;
+        },
+        t(key, params) {
+            const template = resolve(key);
+            if (template === undefined) {
+                onMissing?.(key, active);
+                return key;
+            }
+            return interpolate(template, params);
+        },
+        plural(key, count, params) {
+            const category = pluralCategory(active, count);
+            const template = resolve(`${key}.${category}`) ?? resolve(`${key}.other`) ?? resolve(key);
+            const merged = { count, ...(params ?? {}) };
+            if (template === undefined) {
+                onMissing?.(`${key}.${category}`, active);
+                return key;
+            }
+            return interpolate(template, merged);
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+    return i18n;
+}

package/dist/input/axisInput.d.ts

@@ -73,6 +73,6 @@ export interface GenericAxisChannel<TAxes extends string> {
  * is active), clamped to the axis range; axes without a listed range default to bipolar `[-1, 1]`.
   * @internal
   */
-export declare function sampleAxisBindings<TAxes extends string>(bindings: Record<TAxes, AxisBinding>, isDown: (code: string) => boolean, pointer?: PointerAxisState | null, ranges?: Partial<Record<TAxes, AxisRange>>): Record<TAxes, number>;
+export declare function sampleAxisBindings<TAxes extends string>(bindings: Record<TAxes, AxisBinding>, isDown: (code: string) => boolean, pointer?: PointerAxisState | null, ranges?: Partial<Record<TAxes, AxisRange>>, value?: (code: string) => number): Record<TAxes, number>;
 /** @internal */
 export declare function createAxisChannel<TAxes extends string>(config: GenericAxisConfig<TAxes>): GenericAxisChannel<TAxes>;

package/dist/input/axisInput.js

@@ -25,6 +25,21 @@ function digitalTarget(binding, isDown) {
     const negative = binding.negative !== undefined && binding.negative.some(isDown) ? 1 : 0;
     return positive - negative;
 }
+/** Strongest magnitude across a side's codes — with a `value` source an analog stick contributes its actual deflection; without one this degrades to {@link digitalTarget}'s 0/1. */
+function sideValue(codes, value) {
+    if (codes === undefined)
+        return 0;
+    let strongest = 0;
+    for (const code of codes) {
+        const magnitude = value(code);
+        if (magnitude > strongest)
+            strongest = magnitude;
+    }
+    return strongest;
+}
+function analogTarget(binding, value) {
+    return sideValue(binding.positive, value) - sideValue(binding.negative, value);
+}
 /**
  * Analog control channel — distinct from the digital action bindings. Throttle/brake/steer/handbrake
  * are continuous values ramped from held keys (a keyboard feels like a pedal) or driven directly from
@@ -85,13 +100,14 @@ const BIPOLAR_RANGE = { min: -1, max: 1 };
  * is active), clamped to the axis range; axes without a listed range default to bipolar `[-1, 1]`.
   * @internal
   */
-export function sampleAxisBindings(bindings, isDown, pointer, ranges) {
+export function sampleAxisBindings(bindings, isDown, pointer, ranges, value) {
     const out = {};
     for (const axis of Object.keys(bindings)) {
         const binding = bindings[axis];
         const range = ranges?.[axis] ?? BIPOLAR_RANGE;
         const fromPointer = binding.pointer === undefined ? null : pointerAxisValue(binding.pointer, pointer ?? null);
-        out[axis] = clampAxis(fromPointer ?? digitalTarget(binding, isDown), range);
+        const fromBindings = value === undefined ? digitalTarget(binding, isDown) : analogTarget(binding, value);
+        out[axis] = clampAxis(fromPointer ?? fromBindings, range);
     }
     return out;
 }