@jgengine/core 0.1.0

package/dist/game/trade.d.ts

@@ -0,0 +1,35 @@
+export interface TradeField {
+    buy?: Record<string, number>;
+    sell?: Record<string, number>;
+    shops?: string[];
+}
+export interface TradeRejection {
+    reason: string;
+}
+export interface TradeWallet {
+    canAfford(costs: Record<string, number>): string | null;
+    charge(costs: Record<string, number>): void;
+    grant(gains: Record<string, number>): void;
+}
+export interface TradeInventory {
+    put(inventoryId: string, itemId: string, count: number): TradeRejection | null;
+    take(inventoryId: string, itemId: string, count: number): TradeRejection | null;
+    count(inventoryId: string, itemId: string): number;
+}
+export interface TradeSystemDeps {
+    resolveTrade(itemId: string): TradeField | null | undefined;
+    wallet: TradeWallet;
+    inventory: TradeInventory;
+}
+export interface TradeParty {
+    shop: string;
+    inventoryId: string;
+}
+export interface TradeSystem {
+    canBuy(itemId: string, shopId: string, count?: number): string | null;
+    canSell(itemId: string, count?: number): string | null;
+    buy(itemId: string, count: number | undefined, party: TradeParty): TradeRejection | null;
+    sell(itemId: string, count: number | undefined, party: TradeParty): TradeRejection | null;
+    tradableAt(shopId: string, allItemIds: string[]): string[];
+}
+export declare function createTradeSystem(deps: TradeSystemDeps): TradeSystem;

package/dist/game/trade.js

@@ -0,0 +1,53 @@
+function scale(amounts, count) {
+    const scaled = {};
+    for (const [currency, amount] of Object.entries(amounts))
+        scaled[currency] = amount * count;
+    return scaled;
+}
+export function createTradeSystem(deps) {
+    const { resolveTrade, wallet, inventory } = deps;
+    function canBuy(itemId, shopId, count = 1) {
+        const trade = resolveTrade(itemId);
+        if (!trade?.buy)
+            return "not-purchasable";
+        if (!trade.shops?.includes(shopId))
+            return "not-stocked";
+        return wallet.canAfford(scale(trade.buy, count));
+    }
+    function canSell(itemId, _count = 1) {
+        const trade = resolveTrade(itemId);
+        if (!trade?.sell)
+            return "not-sellable";
+        return null;
+    }
+    return {
+        canBuy,
+        canSell,
+        buy(itemId, count = 1, { shop, inventoryId }) {
+            const rejection = canBuy(itemId, shop, count);
+            if (rejection)
+                return { reason: rejection };
+            const costs = scale(resolveTrade(itemId).buy, count);
+            wallet.charge(costs);
+            const putResult = inventory.put(inventoryId, itemId, count);
+            if (putResult) {
+                wallet.grant(costs);
+                return putResult;
+            }
+            return null;
+        },
+        sell(itemId, count = 1, { inventoryId }) {
+            const rejection = canSell(itemId, count);
+            if (rejection)
+                return { reason: rejection };
+            const takeResult = inventory.take(inventoryId, itemId, count);
+            if (takeResult)
+                return takeResult;
+            wallet.grant(scale(resolveTrade(itemId).sell, count));
+            return null;
+        },
+        tradableAt(shopId, allItemIds) {
+            return allItemIds.filter((itemId) => resolveTrade(itemId)?.shops?.includes(shopId) ?? false);
+        },
+    };
+}

package/dist/game/unlocks.d.ts

@@ -0,0 +1,13 @@
+export interface UnlockDef {
+    id: string;
+    category?: string;
+}
+export interface Unlocks {
+    has(userId: string, unlockId: string): boolean;
+    grant(userId: string, unlockId: string): void;
+    list(userId: string): string[];
+    tree(categoryId: string): UnlockDef[];
+    snapshot(userId: string): string[];
+    hydrate(userId: string, ids: string[]): void;
+}
+export declare function createUnlocks(defs?: UnlockDef[]): Unlocks;

package/dist/game/unlocks.js

@@ -0,0 +1,34 @@
+export function createUnlocks(defs = []) {
+    const definitions = new Map();
+    for (const def of defs)
+        definitions.set(def.id, def);
+    const granted = new Map();
+    function requireGrantedSet(userId) {
+        let set = granted.get(userId);
+        if (!set) {
+            set = new Set();
+            granted.set(userId, set);
+        }
+        return set;
+    }
+    return {
+        has(userId, unlockId) {
+            return granted.get(userId)?.has(unlockId) ?? false;
+        },
+        grant(userId, unlockId) {
+            requireGrantedSet(userId).add(unlockId);
+        },
+        list(userId) {
+            return Array.from(granted.get(userId) ?? []);
+        },
+        tree(categoryId) {
+            return Array.from(definitions.values()).filter((def) => def.category === categoryId);
+        },
+        snapshot(userId) {
+            return Array.from(granted.get(userId) ?? []);
+        },
+        hydrate(userId, ids) {
+            granted.set(userId, new Set(ids));
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./runtime/save.js";
+export * from "./runtime/snapshot.js";
+export * from "./runtime/commandRunner.js";
+export * from "./runtime/gameRuntime.js";
+export * from "./runtime/adapter.js";
+export * from "./runtime/transport.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./runtime/save.js";
+export * from "./runtime/snapshot.js";
+export * from "./runtime/commandRunner.js";
+export * from "./runtime/gameRuntime.js";
+export * from "./runtime/adapter.js";
+export * from "./runtime/transport.js";

package/dist/input/actionBindings.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Action-binding model: games bind semantic actions ("jump", "interact") to
+ * physical control codes; capture layers resolve raw events through this map
+ * so gameplay code never sees keycodes. Control codes are plain strings, so
+ * the same model serves keyboard codes, mouse buttons, touch controls, or
+ * gamepad inputs.
+ */
+export interface ActionBinding<TCode extends string = string> {
+    primary: TCode;
+    secondary: TCode | null;
+}
+export type ActionBindingMap<TAction extends string, TCode extends string = string> = Record<TAction, ActionBinding<TCode>>;
+export declare function bindingMatches<TCode extends string>(code: TCode, binding: ActionBinding<TCode>): boolean;
+/** First action (in the map's key order) bound to the given control code, or null. */
+export declare function resolveBoundAction<TAction extends string, TCode extends string>(code: TCode, bindings: ActionBindingMap<TAction, TCode>): TAction | null;
+/**
+ * Collapse left/right modifier variants of a KeyboardEvent.code so bindings
+ * store one logical key.
+ */
+export declare function normalizeKeyCode(code: string): string;
+export interface ActionBindingModes<TCode extends string = string> {
+    hold?: ActionBinding<TCode>[];
+    toggle?: ActionBinding<TCode>[];
+}
+export type ActionBindingConfig<TCode extends string = string> = ActionBinding<TCode>[] | ActionBindingModes<TCode>;
+export type ActionStateBindingMap<TAction extends string, TCode extends string = string> = Record<TAction, ActionBindingConfig<TCode>>;
+export type ActionCodes<TCode extends string = string> = readonly TCode[] | {
+    hold?: readonly TCode[];
+    toggle?: readonly TCode[];
+};
+export type ActionCodesMap<TAction extends string = string, TCode extends string = string> = Record<TAction, ActionCodes<TCode>>;
+export declare function toActionStateBindingMap<TAction extends string, TCode extends string>(map: ActionCodesMap<TAction, TCode>): ActionStateBindingMap<TAction, TCode>;
+export interface ActionStateTracker<TAction extends string> {
+    handleDown(code: string): TAction | null;
+    handleUp(code: string): TAction | null;
+    isDown(action: TAction): boolean;
+    wasPressed(action: TAction): boolean;
+    endFrame(): void;
+    reset(): void;
+}
+export declare function createActionStateTracker<TAction extends string, TCode extends string = string>(map: ActionStateBindingMap<TAction, TCode>): ActionStateTracker<TAction>;

package/dist/input/actionBindings.js

@@ -0,0 +1,115 @@
+/**
+ * Action-binding model: games bind semantic actions ("jump", "interact") to
+ * physical control codes; capture layers resolve raw events through this map
+ * so gameplay code never sees keycodes. Control codes are plain strings, so
+ * the same model serves keyboard codes, mouse buttons, touch controls, or
+ * gamepad inputs.
+ */
+export function bindingMatches(code, binding) {
+    return code === binding.primary || code === binding.secondary;
+}
+/** First action (in the map's key order) bound to the given control code, or null. */
+export function resolveBoundAction(code, bindings) {
+    for (const action of Object.keys(bindings)) {
+        if (bindingMatches(code, bindings[action]))
+            return action;
+    }
+    return null;
+}
+/**
+ * Collapse left/right modifier variants of a KeyboardEvent.code so bindings
+ * store one logical key.
+ */
+export function normalizeKeyCode(code) {
+    if (code === "ShiftLeft" || code === "ShiftRight")
+        return "Shift";
+    if (code === "ControlLeft" || code === "ControlRight")
+        return "Control";
+    return code;
+}
+function toBindings(codes) {
+    return codes.map((code) => ({ primary: code, secondary: null }));
+}
+export function toActionStateBindingMap(map) {
+    const result = {};
+    for (const action of Object.keys(map)) {
+        const codes = map[action];
+        if (Array.isArray(codes)) {
+            result[action] = toBindings(codes);
+        }
+        else {
+            const modes = codes;
+            result[action] = { hold: toBindings(modes.hold ?? []), toggle: toBindings(modes.toggle ?? []) };
+        }
+    }
+    return result;
+}
+function resolveActionBindingModes(config) {
+    if (Array.isArray(config))
+        return { hold: config, toggle: [] };
+    return { hold: config.hold ?? [], toggle: config.toggle ?? [] };
+}
+export function createActionStateTracker(map) {
+    const actions = Object.keys(map);
+    const modesByAction = new Map(actions.map((action) => [action, resolveActionBindingModes(map[action])]));
+    const heldCodesByAction = new Map(actions.map((action) => [action, new Set()]));
+    const toggledActions = new Set();
+    const pressedThisFrame = new Set();
+    const activeCodes = new Set();
+    function findAction(code, pick) {
+        for (const action of actions) {
+            if (pick(modesByAction.get(action)).some((binding) => bindingMatches(code, binding)))
+                return action;
+        }
+        return null;
+    }
+    return {
+        handleDown(code) {
+            const normalized = normalizeKeyCode(code);
+            if (activeCodes.has(normalized))
+                return null;
+            activeCodes.add(normalized);
+            let matched = null;
+            const holdAction = findAction(normalized, (modes) => modes.hold);
+            if (holdAction !== null) {
+                heldCodesByAction.get(holdAction).add(normalized);
+                pressedThisFrame.add(holdAction);
+                matched = holdAction;
+            }
+            const toggleAction = findAction(normalized, (modes) => modes.toggle);
+            if (toggleAction !== null) {
+                if (toggledActions.has(toggleAction))
+                    toggledActions.delete(toggleAction);
+                else
+                    toggledActions.add(toggleAction);
+                pressedThisFrame.add(toggleAction);
+                matched = matched ?? toggleAction;
+            }
+            return matched;
+        },
+        handleUp(code) {
+            const normalized = normalizeKeyCode(code);
+            activeCodes.delete(normalized);
+            const holdAction = findAction(normalized, (modes) => modes.hold);
+            if (holdAction !== null)
+                heldCodesByAction.get(holdAction).delete(normalized);
+            return holdAction;
+        },
+        isDown(action) {
+            return (heldCodesByAction.get(action)?.size ?? 0) > 0 || toggledActions.has(action);
+        },
+        wasPressed(action) {
+            return pressedThisFrame.has(action);
+        },
+        endFrame() {
+            pressedThisFrame.clear();
+        },
+        reset() {
+            for (const codes of heldCodesByAction.values())
+                codes.clear();
+            toggledActions.clear();
+            pressedThisFrame.clear();
+            activeCodes.clear();
+        },
+    };
+}

package/dist/input/lookChannel.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Per-frame look channel shared between an event-driven capture layer (writer
+ * of raw pointer deltas) and a frame-driven controller (consumer), plus the
+ * latest committed pose for same-frame readers such as presence sync. Kept as
+ * plain mutable state on purpose: routing per-frame deltas through a reactive
+ * store would notify subscribers every frame for state no UI reads.
+ */
+export interface LookDeltas {
+    yaw: number;
+    pitch: number;
+}
+export interface LookChannel {
+    accumulate(dx: number, dy: number): void;
+    /** Yaw/pitch deltas (radians) for this frame; clears the accumulator. */
+    consume(): LookDeltas;
+    setYaw(yaw: number): void;
+    readYaw(): number;
+    setPitch(pitch: number): void;
+    readPitch(): number;
+    setVerticalOffset(offset: number): void;
+    readVerticalOffset(): number;
+}
+export interface LookChannelOptions {
+    /** Radians of rotation per pixel of pointer travel. */
+    sensitivity: number;
+    /** Clamp for the vertical offset register (e.g. peak jump height). */
+    maxVerticalOffset?: number;
+}
+export declare function createLookChannel({ sensitivity, maxVerticalOffset }: LookChannelOptions): LookChannel;

package/dist/input/lookChannel.js

@@ -0,0 +1,44 @@
+/**
+ * Per-frame look channel shared between an event-driven capture layer (writer
+ * of raw pointer deltas) and a frame-driven controller (consumer), plus the
+ * latest committed pose for same-frame readers such as presence sync. Kept as
+ * plain mutable state on purpose: routing per-frame deltas through a reactive
+ * store would notify subscribers every frame for state no UI reads.
+ */
+export function createLookChannel({ sensitivity, maxVerticalOffset = Infinity }) {
+    let deltaX = 0;
+    let deltaY = 0;
+    let yaw = 0;
+    let pitch = 0;
+    let verticalOffset = 0;
+    return {
+        accumulate(dx, dy) {
+            deltaX += dx;
+            deltaY += dy;
+        },
+        consume() {
+            const result = { yaw: -deltaX * sensitivity, pitch: -deltaY * sensitivity };
+            deltaX = 0;
+            deltaY = 0;
+            return result;
+        },
+        setYaw(value) {
+            yaw = value;
+        },
+        readYaw() {
+            return yaw;
+        },
+        setPitch(value) {
+            pitch = value;
+        },
+        readPitch() {
+            return pitch;
+        },
+        setVerticalOffset(value) {
+            verticalOffset = Math.max(0, Math.min(maxVerticalOffset, value));
+        },
+        readVerticalOffset() {
+            return verticalOffset;
+        },
+    };
+}

package/dist/input/touchGestures.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Single-finger gesture disambiguation for touch look controls: one touch
+ * stream drives look-drag, tap, and long-press-hold without fighting.
+ * Movement past the tap threshold commits the gesture to "look" and cancels
+ * tap/hold; a still finger that lifts quickly is a tap; a still finger held
+ * past the long-press delay is a hold. Timestamps are injected so the state
+ * machine stays pure; the capture layer owns timers and touch identifiers.
+ */
+export interface TouchGestureTuning {
+    /** A finger that moves less than this (px) and lifts quickly is a tap. */
+    tapMoveThresholdPx: number;
+    tapMaxMs: number;
+    /** Hold this long without moving to begin a hold gesture. */
+    longPressMs: number;
+}
+export type TouchGestureEnd = "tap" | "hold-end" | null;
+export interface TouchGestureTracker {
+    begin(x: number, y: number, nowMs: number): void;
+    /** Look-drag delta since the last move, or null when no gesture is active. */
+    move(x: number, y: number): {
+        dx: number;
+        dy: number;
+    } | null;
+    /** Commit to a hold if the finger is still down and hasn't moved. */
+    beginHold(): boolean;
+    end(nowMs: number): TouchGestureEnd;
+    cancel(): TouchGestureEnd;
+    isActive(): boolean;
+    isHolding(): boolean;
+}
+export declare function createTouchGestureTracker(tuning: TouchGestureTuning): TouchGestureTracker;

package/dist/input/touchGestures.js

@@ -0,0 +1,72 @@
+/**
+ * Single-finger gesture disambiguation for touch look controls: one touch
+ * stream drives look-drag, tap, and long-press-hold without fighting.
+ * Movement past the tap threshold commits the gesture to "look" and cancels
+ * tap/hold; a still finger that lifts quickly is a tap; a still finger held
+ * past the long-press delay is a hold. Timestamps are injected so the state
+ * machine stays pure; the capture layer owns timers and touch identifiers.
+ */
+export function createTouchGestureTracker(tuning) {
+    let active = false;
+    let moved = false;
+    let holding = false;
+    let startX = 0;
+    let startY = 0;
+    let lastX = 0;
+    let lastY = 0;
+    let startTime = 0;
+    return {
+        begin(x, y, nowMs) {
+            active = true;
+            moved = false;
+            holding = false;
+            startX = lastX = x;
+            startY = lastY = y;
+            startTime = nowMs;
+        },
+        move(x, y) {
+            if (!active)
+                return null;
+            if (!moved && Math.hypot(x - startX, y - startY) > tuning.tapMoveThresholdPx) {
+                moved = true;
+            }
+            const dx = x - lastX;
+            const dy = y - lastY;
+            lastX = x;
+            lastY = y;
+            return { dx, dy };
+        },
+        beginHold() {
+            if (!active || moved || holding)
+                return false;
+            holding = true;
+            return true;
+        },
+        end(nowMs) {
+            if (!active)
+                return null;
+            active = false;
+            if (holding) {
+                holding = false;
+                return "hold-end";
+            }
+            if (!moved && nowMs - startTime <= tuning.tapMaxMs)
+                return "tap";
+            return null;
+        },
+        cancel() {
+            active = false;
+            if (holding) {
+                holding = false;
+                return "hold-end";
+            }
+            return null;
+        },
+        isActive() {
+            return active;
+        },
+        isHolding() {
+            return holding;
+        },
+    };
+}

package/dist/interaction/proximityPrompt.d.ts

@@ -0,0 +1,51 @@
+export interface PromptPoint {
+    x: number;
+    z: number;
+}
+export interface KeybindPromptDisplay {
+    kind: "keybind";
+    actionId: string;
+}
+export interface GaugePromptDisplay {
+    kind: "gauge";
+    gaugeId: string;
+}
+export interface LabelPromptDisplay {
+    kind: "label";
+    text: string;
+}
+export type ProximityPromptDisplay = KeybindPromptDisplay | GaugePromptDisplay | LabelPromptDisplay;
+export declare function keybind(actionId: string): KeybindPromptDisplay;
+export declare function gauge(gaugeId: string): GaugePromptDisplay;
+export declare function label(text: string): LabelPromptDisplay;
+export interface PromptCommand {
+    name: string;
+    input: unknown;
+}
+export declare function command(name: string, input?: unknown): PromptCommand;
+export interface ProximityPrompt {
+    radius: number;
+    display: ProximityPromptDisplay;
+    invoke: PromptCommand | null;
+}
+export interface ProximityPromptConfig {
+    radius: number;
+    display: ProximityPromptDisplay;
+    invoke?: PromptCommand | null;
+}
+export declare function proximityPrompt({ radius, display, invoke }: ProximityPromptConfig): ProximityPrompt;
+export interface PositionedPrompt {
+    id: string;
+    position: PromptPoint;
+    priority?: number;
+    prompt: ProximityPrompt;
+}
+/**
+ * Nearest prompt strictly within its radius wins; a higher-priority prompt in
+ * range beats any lower-priority one regardless of distance; equal priority
+ * and distance keep the earliest prompt in the list.
+ */
+export declare function resolveActivePrompt<T extends PositionedPrompt>(playerPosition: PromptPoint, prompts: readonly T[]): T | null;
+export declare function promptDisplaysEqual(a: ProximityPromptDisplay, b: ProximityPromptDisplay): boolean;
+export declare function promptCommandsEqual(a: PromptCommand | null, b: PromptCommand | null): boolean;
+export declare function positionedPromptsEqual(a: PositionedPrompt, b: PositionedPrompt): boolean;

package/dist/interaction/proximityPrompt.js

@@ -0,0 +1,76 @@
+export function keybind(actionId) {
+    return { kind: "keybind", actionId };
+}
+export function gauge(gaugeId) {
+    return { kind: "gauge", gaugeId };
+}
+export function label(text) {
+    return { kind: "label", text };
+}
+export function command(name, input) {
+    return { name, input };
+}
+export function proximityPrompt({ radius, display, invoke = null }) {
+    return { radius, display, invoke };
+}
+/**
+ * Nearest prompt strictly within its radius wins; a higher-priority prompt in
+ * range beats any lower-priority one regardless of distance; equal priority
+ * and distance keep the earliest prompt in the list.
+ */
+export function resolveActivePrompt(playerPosition, prompts) {
+    let active = null;
+    let activePriority = Number.NEGATIVE_INFINITY;
+    let activeDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of prompts) {
+        const nextDistance = Math.hypot(candidate.position.x - playerPosition.x, candidate.position.z - playerPosition.z);
+        if (nextDistance >= candidate.prompt.radius)
+            continue;
+        const priority = candidate.priority ?? 0;
+        if (priority > activePriority || (priority === activePriority && nextDistance < activeDistance)) {
+            active = candidate;
+            activePriority = priority;
+            activeDistance = nextDistance;
+        }
+    }
+    return active;
+}
+export function promptDisplaysEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a.kind === "keybind")
+        return b.kind === "keybind" && a.actionId === b.actionId;
+    if (a.kind === "gauge")
+        return b.kind === "gauge" && a.gaugeId === b.gaugeId;
+    return b.kind === "label" && a.text === b.text;
+}
+function commandInputsEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+        return false;
+    const aRecord = a;
+    const bRecord = b;
+    const keys = Object.keys(aRecord);
+    if (keys.length !== Object.keys(bRecord).length)
+        return false;
+    return keys.every((key) => Object.is(aRecord[key], bRecord[key]));
+}
+export function promptCommandsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    return a.name === b.name && commandInputsEqual(a.input, b.input);
+}
+export function positionedPromptsEqual(a, b) {
+    if (a === b)
+        return true;
+    return a.id === b.id
+        && a.position.x === b.position.x
+        && a.position.z === b.position.z
+        && (a.priority ?? 0) === (b.priority ?? 0)
+        && a.prompt.radius === b.prompt.radius
+        && promptDisplaysEqual(a.prompt.display, b.prompt.display)
+        && promptCommandsEqual(a.prompt.invoke, b.prompt.invoke);
+}

package/dist/inventory/inventoryModel.d.ts

@@ -0,0 +1,57 @@
+export interface ItemTraits {
+    stackLimit(itemId: string): number;
+    kind?(itemId: string): string | null;
+}
+export interface InventoryLayout {
+    slots: number;
+    accepts?: string | readonly string[];
+}
+export type InventorySlot = {
+    itemId: string;
+    count: number;
+} | null;
+export interface InventoryState {
+    slots: InventorySlot[];
+}
+export type PutResult = {
+    status: "ok";
+    state: InventoryState;
+} | {
+    status: "rejected";
+    reason: "no-space" | "wrong-kind" | "slot-occupied" | "invalid-slot";
+};
+export type TakeResult = {
+    status: "ok";
+    state: InventoryState;
+} | {
+    status: "rejected";
+    reason: "insufficient";
+};
+export type MoveResult = {
+    status: "ok";
+    from: InventoryState;
+    to: InventoryState;
+} | {
+    status: "rejected";
+    reason: "invalid-slot" | "empty-slot" | "wrong-kind" | "no-space";
+};
+export declare function createEmptyInventory(layout: InventoryLayout): InventoryState;
+export declare function putItem(state: InventoryState, layout: InventoryLayout, traits: ItemTraits, itemId: string, count: number, options?: {
+    slot?: number;
+}): PutResult;
+export declare function takeItem(state: InventoryState, itemId: string, count: number): TakeResult;
+export declare function countItem(state: InventoryState, itemId: string): number;
+export declare function hasItem(state: InventoryState, itemId: string, count: number): boolean;
+export declare function moveItem(from: InventoryState, fromSlot: number, to: InventoryState, toLayout: InventoryLayout, traits: ItemTraits, toSlot?: number): MoveResult;
+export interface InventorySet<TId extends string> {
+    put(id: TId, itemId: string, count: number, options?: {
+        slot?: number;
+    }): PutResult;
+    take(id: TId, itemId: string, count: number): TakeResult;
+    move(fromId: TId, fromSlot: number, toId: TId, toSlot?: number): MoveResult;
+    count(id: TId, itemId: string): number;
+    has(id: TId, itemId: string, count: number): boolean;
+    state(id: TId): InventoryState;
+    replaceState(id: TId, state: InventoryState): void;
+}
+export declare function createInventorySet<TId extends string>(layouts: Record<TId, InventoryLayout>, traits: ItemTraits): InventorySet<TId>;