@jgengine/core 0.7.0 → 0.9.0

package/dist/game/social.js

@@ -72,12 +72,25 @@ export function createSocial(deps) {
                     friendRequests.delete(requestId);
             }
         },
+        decline(userId, requestId) {
+            const request = friendRequests.get(requestId);
+            if (request !== undefined && request.to === userId)
+                friendRequests.delete(requestId);
+        },
         list(userId) {
             return Array.from(friendships.get(userId) ?? [], (friendUserId) => ({
                 userId: friendUserId,
                 online: deps.presence?.(friendUserId).online ?? false,
             }));
         },
+        requestsFor(userId) {
+            const entries = [];
+            for (const [requestId, request] of friendRequests) {
+                if (request.to === userId)
+                    entries.push({ requestId, fromUserId: request.from });
+            }
+            return entries;
+        },
         snapshot(userId) {
             return {
                 friends: Array.from(friendships.get(userId) ?? []),
@@ -212,9 +225,117 @@ export function createSocial(deps) {
                 role: member === current.leader ? "leader" : "member",
             }));
         },
+        decline(userId, inviteId) {
+            const invite = partyInvites.get(inviteId);
+            if (invite !== undefined && invite.to === userId)
+                partyInvites.delete(inviteId);
+        },
         membersOf(userId) {
             return partyOf(userId)?.members.slice() ?? [];
         },
+        invitesFor(userId) {
+            const ttlMs = partyConfig?.inviteTtlMs ?? DEFAULT_INVITE_TTL_MS;
+            const cutoff = now() - ttlMs;
+            const entries = [];
+            for (const [inviteId, invite] of partyInvites) {
+                if (invite.createdAt < cutoff) {
+                    partyInvites.delete(inviteId);
+                    continue;
+                }
+                if (invite.to === userId) {
+                    entries.push({ inviteId, fromUserId: invite.from, createdAt: invite.createdAt });
+                }
+            }
+            return entries;
+        },
+    };
+    const worldInviteTtlMs = deps.worldInviteTtlMs ?? DEFAULT_INVITE_TTL_MS;
+    const worldInviteEntries = new Map();
+    let worldInviteCounter = 0;
+    function pruneWorldInvites() {
+        const cutoff = now() - worldInviteTtlMs;
+        for (const [id, entry] of worldInviteEntries) {
+            if (entry.createdAt < cutoff)
+                worldInviteEntries.delete(id);
+        }
+    }
+    function canWorldInvite(fromUserId, toUserId) {
+        if (fromUserId === toUserId)
+            return { reason: "cannot invite yourself" };
+        if (blocked.get(toUserId)?.has(fromUserId) || blocked.get(fromUserId)?.has(toUserId)) {
+            return { reason: "blocked" };
+        }
+        pruneWorldInvites();
+        for (const entry of worldInviteEntries.values()) {
+            if (entry.fromUserId === fromUserId && entry.toUserId === toUserId) {
+                return { reason: "invite already pending" };
+            }
+        }
+        return null;
+    }
+    const worldInvites = {
+        canInvite: canWorldInvite,
+        invite(fromUserId, toUserId, target) {
+            const denied = canWorldInvite(fromUserId, toUserId);
+            if (denied !== null)
+                return denied;
+            worldInviteCounter += 1;
+            const inviteId = `winv_${worldInviteCounter}`;
+            const entry = {
+                id: inviteId,
+                fromUserId,
+                toUserId,
+                serverId: target.serverId,
+                createdAt: now(),
+            };
+            if (target.joinCode !== undefined)
+                entry.joinCode = target.joinCode;
+            worldInviteEntries.set(inviteId, entry);
+            const invited = {
+                inviteId,
+                fromUserId,
+                toUserId,
+                serverId: target.serverId,
+            };
+            if (target.joinCode !== undefined)
+                invited.joinCode = target.joinCode;
+            events.emit("social.world.invited", invited);
+            return { inviteId };
+        },
+        accept(userId, inviteId) {
+            const entry = worldInviteEntries.get(inviteId);
+            if (entry === undefined)
+                return { reason: `unknown invite "${inviteId}"` };
+            if (entry.toUserId !== userId)
+                return { reason: "invite is not addressed to this user" };
+            if (now() - entry.createdAt > worldInviteTtlMs) {
+                worldInviteEntries.delete(inviteId);
+                return { reason: "invite expired" };
+            }
+            worldInviteEntries.delete(inviteId);
+            const target = { serverId: entry.serverId };
+            if (entry.joinCode !== undefined)
+                target.joinCode = entry.joinCode;
+            const accepted = {
+                inviteId,
+                userId,
+                fromUserId: entry.fromUserId,
+                serverId: entry.serverId,
+            };
+            if (entry.joinCode !== undefined)
+                accepted.joinCode = entry.joinCode;
+            events.emit("social.world.accepted", accepted);
+            return { target };
+        },
+        decline(userId, inviteId) {
+            const entry = worldInviteEntries.get(inviteId);
+            if (entry !== undefined && entry.toUserId === userId)
+                worldInviteEntries.delete(inviteId);
+        },
+        listFor(userId) {
+            pruneWorldInvites();
+            return Array.from(worldInviteEntries.values()).filter((entry) => entry.toUserId === userId);
+        },
     };
     const emotes = {
         play(fromUserId, emoteId, radius) {
@@ -239,5 +360,6 @@ export function createSocial(deps) {
             },
         },
         emotes,
+        worldInvites,
     };
 }

package/dist/game/spawnPoints.d.ts

@@ -0,0 +1,19 @@
+import type { EntityPose } from "../scene/entityStore.js";
+export interface SpawnPointPose {
+    x: number;
+    y: number;
+    z: number;
+    rotationY?: number;
+}
+export interface RespawnTarget {
+    setPose(id: string, pose: EntityPose): boolean;
+}
+export interface SpawnPoints {
+    record(id: string, pose: SpawnPointPose): void;
+    get(id: string): SpawnPointPose | undefined;
+    list(): readonly (SpawnPointPose & {
+        id: string;
+    })[];
+    respawn(entities: RespawnTarget, entityId: string, spawnId: string): boolean;
+}
+export declare function createSpawnPoints(): SpawnPoints;

package/dist/game/spawnPoints.js

@@ -0,0 +1,23 @@
+export function createSpawnPoints() {
+    const points = new Map();
+    return {
+        record(id, pose) {
+            points.set(id, { ...pose });
+        },
+        get(id) {
+            return points.get(id);
+        },
+        list() {
+            return Array.from(points, ([id, pose]) => ({ id, ...pose }));
+        },
+        respawn(entities, entityId, spawnId) {
+            const pose = points.get(spawnId);
+            if (pose === undefined)
+                return false;
+            return entities.setPose(entityId, {
+                position: { x: pose.x, y: pose.y, z: pose.z },
+                ...(pose.rotationY === undefined ? {} : { rotationY: pose.rotationY }),
+            });
+        },
+    };
+}

package/dist/game/talents.d.ts

@@ -0,0 +1,47 @@
+import type { StatModifierSet } from "../stats/statModifiers.js";
+export type TalentRequirement = string | {
+    nodeId: string;
+    rank: number;
+};
+export interface TalentNodeDef<TStat extends string = string> {
+    id: string;
+    branch?: string;
+    maxRank: number;
+    requires?: readonly TalentRequirement[];
+    requiresPointsInBranch?: number;
+    modifiersPerRank?: StatModifierSet<TStat>;
+    grantsAbilities?: readonly string[];
+}
+export type TalentAllocateReason = "unknown-node" | "max-rank" | "no-points" | "requires" | "branch-points";
+export type TalentAllocateResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: TalentAllocateReason;
+};
+export interface ResolvedTalents<TStat extends string = string> {
+    stats: StatModifierSet<TStat>;
+    abilities: readonly string[];
+}
+export interface TalentSnapshot {
+    points: number;
+    ranks: Record<string, number>;
+}
+export interface TalentTreeConfig<TStat extends string = string> {
+    nodes: readonly TalentNodeDef<TStat>[];
+    points?: number;
+}
+export interface TalentTree<TStat extends string = string> {
+    rank(nodeId: string): number;
+    pointsAvailable(): number;
+    pointsSpent(): number;
+    pointsInBranch(branch: string): number;
+    grantPoints(amount: number): void;
+    canAllocate(nodeId: string): TalentAllocateResult;
+    allocate(nodeId: string): TalentAllocateResult;
+    resolved(): ResolvedTalents<TStat>;
+    reset(): void;
+    snapshot(): TalentSnapshot;
+    hydrate(snapshot: TalentSnapshot): void;
+}
+export declare function createTalentTree<TStat extends string = string>(config: TalentTreeConfig<TStat>): TalentTree<TStat>;

package/dist/game/talents.js

@@ -0,0 +1,140 @@
+const DEFAULT_BRANCH = "";
+export function createTalentTree(config) {
+    const nodesById = new Map();
+    for (const node of config.nodes)
+        nodesById.set(node.id, node);
+    const ranks = new Map();
+    let points = Math.max(0, config.points ?? 0);
+    let cache = null;
+    function rank(nodeId) {
+        return ranks.get(nodeId) ?? 0;
+    }
+    function branchOf(node) {
+        return node.branch ?? DEFAULT_BRANCH;
+    }
+    function pointsInBranch(branch) {
+        let total = 0;
+        for (const node of nodesById.values()) {
+            if (branchOf(node) === branch)
+                total += rank(node.id);
+        }
+        return total;
+    }
+    function pointsSpent() {
+        let total = 0;
+        for (const value of ranks.values())
+            total += value;
+        return total;
+    }
+    function requirementUnmet(requirement) {
+        const reqNodeId = typeof requirement === "string" ? requirement : requirement.nodeId;
+        const reqRank = typeof requirement === "string" ? 1 : requirement.rank;
+        return rank(reqNodeId) < reqRank;
+    }
+    function canAllocate(nodeId) {
+        const node = nodesById.get(nodeId);
+        if (!node)
+            return { ok: false, reason: "unknown-node" };
+        const currentRank = rank(nodeId);
+        if (currentRank >= node.maxRank)
+            return { ok: false, reason: "max-rank" };
+        if (points < 1)
+            return { ok: false, reason: "no-points" };
+        for (const requirement of node.requires ?? []) {
+            if (requirementUnmet(requirement))
+                return { ok: false, reason: "requires" };
+        }
+        if (node.requiresPointsInBranch !== undefined) {
+            const inBranch = pointsInBranch(branchOf(node)) - currentRank;
+            if (inBranch < node.requiresPointsInBranch)
+                return { ok: false, reason: "branch-points" };
+        }
+        return { ok: true };
+    }
+    function resolve() {
+        const stats = {};
+        const abilities = [];
+        const seenAbilities = new Set();
+        for (const node of nodesById.values()) {
+            const nodeRank = rank(node.id);
+            if (nodeRank <= 0)
+                continue;
+            if (node.modifiersPerRank) {
+                for (const stat of Object.keys(node.modifiersPerRank)) {
+                    const modifier = node.modifiersPerRank[stat];
+                    if (!modifier)
+                        continue;
+                    const entry = stats[stat] ?? {};
+                    if (modifier.add !== undefined)
+                        entry.add = (entry.add ?? 0) + modifier.add * nodeRank;
+                    if (modifier.multiply !== undefined) {
+                        entry.multiply = (entry.multiply ?? 1) * Math.pow(modifier.multiply, nodeRank);
+                    }
+                    stats[stat] = entry;
+                }
+            }
+            if (node.grantsAbilities) {
+                for (const ability of node.grantsAbilities) {
+                    if (seenAbilities.has(ability))
+                        continue;
+                    seenAbilities.add(ability);
+                    abilities.push(ability);
+                }
+            }
+        }
+        return { stats, abilities };
+    }
+    return {
+        rank,
+        pointsAvailable() {
+            return points;
+        },
+        pointsSpent,
+        pointsInBranch,
+        grantPoints(amount) {
+            if (amount > 0)
+                points += amount;
+        },
+        canAllocate,
+        allocate(nodeId) {
+            const result = canAllocate(nodeId);
+            if (!result.ok)
+                return result;
+            points -= 1;
+            ranks.set(nodeId, rank(nodeId) + 1);
+            cache = null;
+            return { ok: true };
+        },
+        resolved() {
+            if (cache === null)
+                cache = resolve();
+            return cache;
+        },
+        reset() {
+            points += pointsSpent();
+            ranks.clear();
+            cache = null;
+        },
+        snapshot() {
+            const snapshotRanks = {};
+            for (const [nodeId, value] of ranks) {
+                if (value > 0)
+                    snapshotRanks[nodeId] = value;
+            }
+            return { points, ranks: snapshotRanks };
+        },
+        hydrate(snapshot) {
+            ranks.clear();
+            points = snapshot.points;
+            for (const [nodeId, value] of Object.entries(snapshot.ranks)) {
+                const node = nodesById.get(nodeId);
+                if (!node)
+                    continue;
+                const clamped = Math.max(0, Math.min(value, node.maxRank));
+                if (clamped > 0)
+                    ranks.set(nodeId, clamped);
+            }
+            cache = null;
+        },
+    };
+}

package/dist/game/worldItem.d.ts

@@ -44,7 +44,10 @@ export interface WorldItemStore {
     get(instanceId: string): WorldItemRecord | null;
     list(): readonly WorldItemRecord[];
     nearestInRadius(from: EntityPosition, radius: number, filter?: (record: WorldItemRecord) => boolean): string | null;
+    /** Detaches the record for a pickup: caller is expected to grant its contents (e.g. `loot.grantToPlayer`) itself. */
     take(instanceId: string): WorldItemRecord | null;
+    /** Consumes/destroys the record with no grant implied (decay, an explosion, a cleanup sweep) — same despawn path as `take`, leaves no orphaned record. */
+    remove(instanceId: string): WorldItemRecord | null;
 }
 /** Pure pickup-radius + nearest-item selection, usable without a live store (click-to-grab, proximity prompts). */
 export declare function selectNearestWorldItem(candidates: readonly {

package/dist/game/worldItem.js

@@ -33,6 +33,14 @@ export function selectNearestWorldItem(candidates, from, radius) {
 export function createWorldItemStore(deps) {
     const records = new Map();
     const now = deps.now ?? Date.now;
+    function removeRecord(instanceId) {
+        const record = records.get(instanceId);
+        if (record === undefined)
+            return null;
+        records.delete(instanceId);
+        deps.despawnEntity(instanceId);
+        return record;
+    }
     return {
         spawn(input) {
             const instanceId = deps.spawnEntity(input.position);
@@ -69,12 +77,10 @@ export function createWorldItemStore(deps) {
             return selectNearestWorldItem(candidates, from, radius);
         },
         take(instanceId) {
-            const record = records.get(instanceId);
-            if (record === undefined)
-                return null;
-            records.delete(instanceId);
-            deps.despawnEntity(instanceId);
-            return record;
+            return removeRecord(instanceId);
+        },
+        remove(instanceId) {
+            return removeRecord(instanceId);
         },
     };
 }

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from "./runtime/commandRunner.js";
 export * from "./runtime/gameRuntime.js";
 export * from "./runtime/adapter.js";
 export * from "./runtime/transport.js";
+export * from "./runtime/visibility.js";

package/dist/index.js

@@ -4,3 +4,4 @@ export * from "./runtime/commandRunner.js";
 export * from "./runtime/gameRuntime.js";
 export * from "./runtime/adapter.js";
 export * from "./runtime/transport.js";
+export * from "./runtime/visibility.js";

package/dist/input/actionBindings.d.ts

@@ -27,8 +27,18 @@ export type ActionStateBindingMap<TAction extends string, TCode extends string =
 export type ActionCodes<TCode extends string = string> = readonly TCode[] | {
     hold?: readonly TCode[];
     toggle?: readonly TCode[];
+    repeatMs?: number;
 };
 export type ActionCodesMap<TAction extends string = string, TCode extends string = string> = Record<TAction, ActionCodes<TCode>>;
+export declare function actionRepeatMs(codes: ActionCodes | undefined): number | undefined;
+export interface ShouldDispatchActionInput {
+    pressed: boolean;
+    down: boolean;
+    repeatMs: number | undefined;
+    lastFiredAt: number | null;
+    now: number;
+}
+export declare function shouldDispatchAction({ pressed, down, repeatMs, lastFiredAt, now }: ShouldDispatchActionInput): boolean;
 export declare function toActionStateBindingMap<TAction extends string, TCode extends string>(map: ActionCodesMap<TAction, TCode>): ActionStateBindingMap<TAction, TCode>;
 export declare function hotbarSlotBindings(count: number, options?: {
     action?: (slot: number) => string;

package/dist/input/actionBindings.js

@@ -27,6 +27,20 @@ export function normalizeKeyCode(code) {
         return "Control";
     return code;
 }
+export function actionRepeatMs(codes) {
+    if (codes === undefined || Array.isArray(codes))
+        return undefined;
+    return codes.repeatMs;
+}
+export function shouldDispatchAction({ pressed, down, repeatMs, lastFiredAt, now }) {
+    if (pressed)
+        return true;
+    if (repeatMs === undefined || repeatMs <= 0)
+        return false;
+    if (!down || lastFiredAt === null)
+        return false;
+    return now - lastFiredAt >= repeatMs;
+}
 function toBindings(codes) {
     return codes.map((code) => ({ primary: code, secondary: null }));
 }

package/dist/input/axisInput.d.ts

@@ -1,3 +1,4 @@
+import { type PointerAxisBinding, type PointerAxisState } from "./pointerAxis.js";
 export interface AxisInput {
     throttle: number;
     brake: number;
@@ -9,6 +10,8 @@ export type AxisName = keyof AxisInput;
 export interface AxisBinding {
     positive: readonly string[];
     negative?: readonly string[];
+    /** Pointer-position source for this axis (#293) — takes over from the key lists whenever a pointer is active. */
+    pointer?: PointerAxisBinding;
 }
 export type AxisBindingMap = Record<AxisName, AxisBinding>;
 export interface AxisChannelConfig {
@@ -25,8 +28,9 @@ export declare function rampToward(current: number, target: number, rate: number
 /**
  * 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
- * a gamepad axis via `setAnalog`. `sample(dt, isDown)` folds the current held-key state into the
- * smoothed value; a `setAnalog` override replaces the digital target for that axis until cleared.
+ * a gamepad axis via `setAnalog`. `sample(dt, isDown, pointer?)` folds the current held-key state into
+ * the smoothed value; a binding's `pointer` source takes over from its keys while a pointer is active,
+ * and a `setAnalog` override replaces both for that axis until cleared.
  */
 export declare class AxisChannel {
     private readonly bindings;
@@ -38,6 +42,25 @@ export declare class AxisChannel {
     clearAnalog(axis: AxisName): void;
     reset(): void;
     get value(): AxisInput;
-    sample(dt: number, isDown: (code: string) => boolean): AxisInput;
+    sample(dt: number, isDown: (code: string) => boolean, pointer?: PointerAxisState | null): AxisInput;
 }
 export declare const DRIVE_AXIS_BINDINGS: AxisBindingMap;
+export interface GenericAxisConfig<TAxes extends string> {
+    bindings: Record<TAxes, AxisBinding>;
+    /** Per-axis value range; unlisted axes default to bipolar `[-1, 1]` (use `{ min: 0, max: 1 }` for pedals). */
+    ranges?: Partial<Record<TAxes, AxisRange>>;
+    smoothing?: number;
+}
+/**
+ * The held-key-ramping analog channel for any axis schema (#282.7) — drones (pitch/roll/strafe),
+ * boats, mechs — not just the four car axes `AxisChannel` hardcodes. Same semantics: keys ramp,
+ * `setAnalog` overrides, a binding's `pointer` source takes over while a pointer is active.
+ */
+export interface GenericAxisChannel<TAxes extends string> {
+    sample(dt: number, isDown: (code: string) => boolean, pointer?: PointerAxisState | null): Record<TAxes, number>;
+    setAnalog(axis: TAxes, value: number): void;
+    clearAnalog(axis: TAxes): void;
+    reset(): void;
+    readonly value: Record<TAxes, number>;
+}
+export declare function createAxisChannel<TAxes extends string>(config: GenericAxisConfig<TAxes>): GenericAxisChannel<TAxes>;

package/dist/input/axisInput.js

@@ -1,3 +1,4 @@
+import { pointerAxisValue } from "./pointerAxis.js";
 export const NEUTRAL_AXIS = { throttle: 0, brake: 0, steer: 0, handbrake: 0 };
 export const AXIS_RANGE = {
     throttle: { min: 0, max: 1 },
@@ -25,8 +26,9 @@ function digitalTarget(binding, isDown) {
 /**
  * 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
- * a gamepad axis via `setAnalog`. `sample(dt, isDown)` folds the current held-key state into the
- * smoothed value; a `setAnalog` override replaces the digital target for that axis until cleared.
+ * a gamepad axis via `setAnalog`. `sample(dt, isDown, pointer?)` folds the current held-key state into
+ * the smoothed value; a binding's `pointer` source takes over from its keys while a pointer is active,
+ * and a `setAnalog` override replaces both for that axis until cleared.
  */
 export class AxisChannel {
     bindings;
@@ -52,11 +54,15 @@ export class AxisChannel {
     get value() {
         return this.current;
     }
-    sample(dt, isDown) {
+    sample(dt, isDown, pointer) {
         for (const axis of Object.keys(this.bindings)) {
             const range = AXIS_RANGE[axis];
             const override = this.overrides[axis];
-            const target = override !== undefined ? override : clampAxis(digitalTarget(this.bindings[axis], isDown), range);
+            const binding = this.bindings[axis];
+            const fromPointer = binding.pointer === undefined ? null : pointerAxisValue(binding.pointer, pointer);
+            const target = override !== undefined
+                ? override
+                : clampAxis(fromPointer ?? digitalTarget(binding, isDown), range);
             this.current[axis] = clampAxis(rampToward(this.current[axis], target, this.smoothing, dt), range);
         }
         return this.current;
@@ -68,3 +74,37 @@ export const DRIVE_AXIS_BINDINGS = {
     steer: { positive: ["KeyD", "ArrowRight"], negative: ["KeyA", "ArrowLeft"] },
     handbrake: { positive: ["Space"] },
 };
+const BIPOLAR_RANGE = { min: -1, max: 1 };
+export function createAxisChannel(config) {
+    const axes = Object.keys(config.bindings);
+    const smoothing = config.smoothing ?? 6;
+    const current = Object.fromEntries(axes.map((axis) => [axis, 0]));
+    const overrides = {};
+    function rangeOf(axis) {
+        return config.ranges?.[axis] ?? BIPOLAR_RANGE;
+    }
+    return {
+        value: current,
+        setAnalog(axis, value) {
+            overrides[axis] = clampAxis(value, rangeOf(axis));
+        },
+        clearAnalog(axis) {
+            delete overrides[axis];
+        },
+        reset() {
+            for (const axis of axes)
+                current[axis] = 0;
+        },
+        sample(dt, isDown, pointer) {
+            for (const axis of axes) {
+                const range = rangeOf(axis);
+                const override = overrides[axis];
+                const binding = config.bindings[axis];
+                const fromPointer = binding.pointer === undefined ? null : pointerAxisValue(binding.pointer, pointer);
+                const target = override !== undefined ? override : clampAxis(fromPointer ?? digitalTarget(binding, isDown), range);
+                current[axis] = clampAxis(rampToward(current[axis], target, smoothing, dt), range);
+            }
+            return current;
+        },
+    };
+}

package/dist/input/bindingOverrides.d.ts

@@ -0,0 +1,25 @@
+import type { ActionCodes, ActionCodesMap } from "./actionBindings.js";
+/**
+ * Player-rebound keys, keyed by action name. Values mirror an `ActionCodes`
+ * entry so hold/toggle/repeat semantics survive a rebind — the settings menu
+ * only swaps which physical codes drive the action.
+ */
+export type BindingOverrides = Record<string, ActionCodes>;
+export declare const BINDING_OVERRIDES_STORAGE_PREFIX = "jgengine:keybinds:";
+interface WebStorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export declare function bindingOverridesStorageKey(gameId: string): string;
+export declare function loadBindingOverrides(gameId: string, storage?: Pick<WebStorageLike, "getItem"> | null | undefined): BindingOverrides;
+export declare function saveBindingOverride(gameId: string, action: string, codes: ActionCodes, storage?: Pick<WebStorageLike, "getItem" | "setItem" | "removeItem"> | null | undefined): BindingOverrides;
+export declare function clearBindingOverride(gameId: string, action: string, storage?: Pick<WebStorageLike, "getItem" | "setItem" | "removeItem"> | null | undefined): BindingOverrides;
+export declare function clearAllBindingOverrides(gameId: string, storage?: Pick<WebStorageLike, "removeItem"> | null | undefined): void;
+/**
+ * Merge player rebinds over a game's authored `input` map. Only actions the
+ * game already declares can be overridden; unknown override keys are ignored so
+ * a stale localStorage entry can't inject phantom actions.
+ */
+export declare function applyBindingOverrides<TAction extends string, TCode extends string>(input: ActionCodesMap<TAction, TCode>, overrides: BindingOverrides): ActionCodesMap<TAction, TCode>;
+export {};