@jgengine/core 0.14.0 → 0.15.0-next.0

package/dist/input/rebindSession.js

@@ -0,0 +1,235 @@
+import { bindingLabel, normalizeKeyCode, } from "./actionBindings.js";
+import { applyBindingOverrides } from "./bindingOverrides.js";
+/** All codes an {@link ActionCodes} entry binds (hold + toggle, or the plain array). */
+function allCodes(codes) {
+    if (Array.isArray(codes))
+        return [...codes];
+    const modes = codes;
+    return [...(modes.hold ?? []), ...(modes.toggle ?? [])];
+}
+/** The first (primary) code of an {@link ActionCodes} entry, or `null` when unbound. */
+function primaryCode(codes) {
+    return allCodes(codes)[0] ?? null;
+}
+/** Replace the primary code of `codes` with `code`, keeping the hold/toggle/repeat shape. */
+function withPrimaryCode(codes, code) {
+    if (Array.isArray(codes)) {
+        return [code, ...codes.slice(1)];
+    }
+    const modes = codes;
+    if (modes.hold !== undefined && modes.hold.length > 0) {
+        return { ...modes, hold: [code, ...modes.hold.slice(1)] };
+    }
+    if (modes.toggle !== undefined && modes.toggle.length > 0) {
+        return { ...modes, toggle: [code, ...modes.toggle.slice(1)] };
+    }
+    return { ...modes, hold: [code] };
+}
+function normalizeConfig(config) {
+    if ("actions" in config)
+        return config.actions.map((a) => ({ ...a }));
+    const labels = config.labels ?? {};
+    return Object.keys(config.input).map((id) => ({
+        id,
+        label: labels[id] ?? id,
+        defaultCodes: config.input[id],
+    }));
+}
+/**
+ * A conflict-aware key-remap session over the action-binding model — the missing
+ * editor behind a controls-settings menu. It takes the game's authored actions
+ * ({@link RebindActionConfig}s, or an {@link ActionCodesMap} + labels) plus the
+ * player's saved {@link BindingOverrides}, and tracks the *effective* binding per
+ * action (default merged with the override via `applyBindingOverrides`). `rows()`
+ * exposes each action's label, current key glyph (via `bindingLabel`), whether it
+ * is still the default, and which other actions it collides with; `conflicts()`
+ * groups every action pair sharing a normalized code (the value-add a raw
+ * override map can't give you). `beginCapture`/`capture`/`cancelCapture` drive a
+ * "press a key" rebind (codes normalized via `normalizeKeyCode`), `reset`/
+ * `resetAll` return to defaults, and `overrides()`/`apply()` hand the caller the
+ * `BindingOverrides` to persist. Nothing here is genre-specific: action ids and
+ * labels are free strings the session never interprets, and hold/toggle/repeat
+ * binding shapes survive a rebind. `snapshot`/`restore` round-trips the editor
+ * (including the in-flight capture) through a save.
+ *
+ * @capability key-rebinding conflict-aware key-remap session over the action-binding model — capture/reassign, conflict detection, reset-to-defaults, persist overrides, snapshot/restore
+ */
+export function createRebindSession(config) {
+    const now = config.now ?? Date.now;
+    const actionList = normalizeConfig(config);
+    const defaultMap = {};
+    for (const action of actionList)
+        defaultMap[action.id] = action.defaultCodes;
+    const knownIds = new Set(actionList.map((a) => a.id));
+    const overrides = {};
+    const changedAt = new Map();
+    let capturingActionId = null;
+    const listeners = new Set();
+    function ingestOverrides(source) {
+        for (const id of Object.keys(source)) {
+            if (knownIds.has(id))
+                overrides[id] = source[id];
+        }
+    }
+    if (config.overrides !== undefined)
+        ingestOverrides(config.overrides);
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    /** Effective codes for an action: override merged over the authored default. */
+    function effectiveMap() {
+        return applyBindingOverrides(defaultMap, overrides);
+    }
+    /** Map of normalized code → action ids currently bound to it. */
+    function codeIndex() {
+        const effective = effectiveMap();
+        const index = new Map();
+        for (const action of actionList) {
+            for (const raw of allCodes(effective[action.id])) {
+                const norm = normalizeKeyCode(raw);
+                const bucket = index.get(norm);
+                if (bucket === undefined)
+                    index.set(norm, [action.id]);
+                else
+                    bucket.push(action.id);
+            }
+        }
+        return index;
+    }
+    function rows() {
+        const effective = effectiveMap();
+        const index = codeIndex();
+        return actionList.map((action) => {
+            const codes = effective[action.id];
+            const primaryRaw = primaryCode(codes);
+            const primary = primaryRaw === null ? null : normalizeKeyCode(primaryRaw);
+            const conflictWith = new Set();
+            for (const raw of allCodes(codes)) {
+                const bound = index.get(normalizeKeyCode(raw));
+                if (bound === undefined)
+                    continue;
+                for (const other of bound)
+                    if (other !== action.id)
+                        conflictWith.add(other);
+            }
+            return {
+                actionId: action.id,
+                label: action.label,
+                codes,
+                code: primary,
+                bindingLabel: primary === null ? "" : bindingLabel(primary),
+                isDefault: overrides[action.id] === undefined,
+                conflictWith: [...conflictWith],
+                changedAt: changedAt.get(action.id) ?? null,
+            };
+        });
+    }
+    return {
+        actions() {
+            return actionList;
+        },
+        rows,
+        row(actionId) {
+            return rows().find((r) => r.actionId === actionId) ?? null;
+        },
+        beginCapture(actionId) {
+            if (!knownIds.has(actionId) || capturingActionId === actionId)
+                return;
+            capturingActionId = actionId;
+            notify();
+        },
+        capturingActionId() {
+            return capturingActionId;
+        },
+        isCapturing(actionId) {
+            if (actionId === undefined)
+                return capturingActionId !== null;
+            return capturingActionId === actionId;
+        },
+        capture(code) {
+            const target = capturingActionId;
+            if (target === null)
+                return false;
+            const normalized = normalizeKeyCode(code);
+            const base = effectiveMap()[target];
+            overrides[target] = withPrimaryCode(base, normalized);
+            changedAt.set(target, now());
+            capturingActionId = null;
+            notify();
+            return true;
+        },
+        cancelCapture() {
+            if (capturingActionId === null)
+                return;
+            capturingActionId = null;
+            notify();
+        },
+        conflicts() {
+            const groups = [];
+            for (const [code, actionIds] of codeIndex()) {
+                if (actionIds.length >= 2)
+                    groups.push({ code, actionIds: [...actionIds] });
+            }
+            return groups;
+        },
+        hasConflicts() {
+            for (const actionIds of codeIndex().values())
+                if (actionIds.length >= 2)
+                    return true;
+            return false;
+        },
+        reset(actionId) {
+            if (overrides[actionId] === undefined)
+                return;
+            delete overrides[actionId];
+            changedAt.delete(actionId);
+            notify();
+        },
+        resetAll() {
+            if (Object.keys(overrides).length === 0 && changedAt.size === 0)
+                return;
+            for (const key of Object.keys(overrides))
+                delete overrides[key];
+            changedAt.clear();
+            notify();
+        },
+        isDefault(actionId) {
+            return overrides[actionId] === undefined;
+        },
+        overrides() {
+            return { ...overrides };
+        },
+        apply(persistFn) {
+            const snapshot = { ...overrides };
+            persistFn?.(snapshot);
+            return snapshot;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        snapshot() {
+            return {
+                overrides: { ...overrides },
+                changedAt: Object.fromEntries(changedAt),
+                capturingActionId,
+            };
+        },
+        restore(snapshot) {
+            for (const key of Object.keys(overrides))
+                delete overrides[key];
+            changedAt.clear();
+            ingestOverrides(snapshot.overrides);
+            for (const [id, at] of Object.entries(snapshot.changedAt)) {
+                if (knownIds.has(id))
+                    changedAt.set(id, at);
+            }
+            capturingActionId =
+                snapshot.capturingActionId !== null && knownIds.has(snapshot.capturingActionId)
+                    ? snapshot.capturingActionId
+                    : null;
+            notify();
+        },
+    };
+}

package/dist/input/touchControlsMode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runtime switch for the active touch control context (see `TouchControlsConfig.modes`): gameplay
+ * calls `setTouchControlsMode(ctx, "car")` when the player boards a vehicle and `null` on exit, and
+ * the shell re-derives the touch scheme so only that context's controls are on screen. Backed by the
+ * ctx keyed store, so writes notify `ctx.subscribe` (the shell re-renders) and the value rides along
+ * with whole-world saves exactly like the gameplay state that implies it.
+ */
+import type { GameContext } from "../runtime/gameContext.js";
+/**
+ * Activate a named touch control mode, or `null` to return to the base config.
+ *
+ * @capability touch-controls switch the on-screen touch control set when gameplay context changes (enter/exit vehicle, mount, build mode)
+ */
+export declare function setTouchControlsMode(ctx: GameContext, mode: string | null): void;
+/** The active touch control mode, `null` when the base config applies. */
+export declare function activeTouchControlsMode(ctx: GameContext): string | null;

package/dist/input/touchControlsMode.js

@@ -0,0 +1,23 @@
+/**
+ * Runtime switch for the active touch control context (see `TouchControlsConfig.modes`): gameplay
+ * calls `setTouchControlsMode(ctx, "car")` when the player boards a vehicle and `null` on exit, and
+ * the shell re-derives the touch scheme so only that context's controls are on screen. Backed by the
+ * ctx keyed store, so writes notify `ctx.subscribe` (the shell re-renders) and the value rides along
+ * with whole-world saves exactly like the gameplay state that implies it.
+ */
+import { defineStore } from "../store/defineStore.js";
+const touchModeStore = defineStore("engine.touch.mode", null);
+/**
+ * Activate a named touch control mode, or `null` to return to the base config.
+ *
+ * @capability touch-controls switch the on-screen touch control set when gameplay context changes (enter/exit vehicle, mount, build mode)
+ */
+export function setTouchControlsMode(ctx, mode) {
+    if (touchModeStore.read(ctx) === mode)
+        return;
+    touchModeStore.write(ctx, mode);
+}
+/** The active touch control mode, `null` when the base config applies. */
+export function activeTouchControlsMode(ctx) {
+    return touchModeStore.read(ctx);
+}

package/dist/input/touchScheme.d.ts

@@ -62,6 +62,22 @@ export declare const TOUCH_STYLE_OPTIONS: readonly {
 }[];
 /** Skin used when neither the game nor the player picks one. */
 export declare const DEFAULT_TOUCH_STYLE: TouchStyle;
+/**
+ * How the movement joystick behaves — the two shipped variants, player-selectable in
+ * Settings → Controls. `fixed` is the classic always-visible stick in its dock corner;
+ * `floating` keeps the corner as an empty capture zone and spawns the stick centered under
+ * wherever the thumb lands, so the hand never has to find a fixed target mid-play.
+ */
+export type TouchJoystickVariant = "fixed" | "floating";
+/** Every joystick variant id, in menu order. */
+export declare const TOUCH_JOYSTICK_VARIANTS: readonly TouchJoystickVariant[];
+/** Joystick variants as `{ value, label }` rows for the Settings → Controls selector. */
+export declare const TOUCH_JOYSTICK_VARIANT_OPTIONS: readonly {
+    value: TouchJoystickVariant;
+    label: string;
+}[];
+/** Variant used when the player has not picked one. */
+export declare const DEFAULT_TOUCH_JOYSTICK_VARIANT: TouchJoystickVariant;
 /** Where each touch cluster docks; unset falls back to the classic bottom layout. */
 export interface TouchLayoutConfig {
     /** Virtual joystick / movement zone. Default `bottom-left`. */
@@ -95,6 +111,9 @@ export interface TouchButtonSpec {
 export interface TouchMovementConfig {
     axis?: "both" | "horizontal" | "vertical";
 }
+/** One named control context's touch config — the same shape as the base config, minus nested modes. */
+export type TouchControlsModeConfig = Omit<TouchControlsConfig, "modes">;
+/** Game-authored refinement of the derived touch scheme on `defineGame({ touch })` — gestures, curated buttons, hidden actions, cluster layout, skin, and per-context `modes`. */
 export interface TouchControlsConfig {
     /** `false` removes the virtual joystick even when movement actions are bound; an object restricts it to one axis. */
     movement?: false | TouchMovementConfig;
@@ -112,6 +131,14 @@ export interface TouchControlsConfig {
     layout?: TouchLayoutConfig;
     /** Suggested default skin; the player's Settings choice overrides it. Default `glass`. */
     style?: TouchStyle;
+    /**
+     * Per-context control sets for games whose verbs change at runtime — on foot vs driving vs
+     * flying. Each key is a mode name whose fields *replace* the matching base fields while that
+     * mode is active (base config = the default mode). Gameplay switches with
+     * `setTouchControlsMode(ctx, "car")` and back with `null`; only the actions a context actually
+     * uses should be visible in it, so a runner on foot never sees flight or vehicle chrome.
+     */
+    modes?: Record<string, TouchControlsModeConfig>;
 }
 export interface TouchJoystick {
     up: string | null;
@@ -157,9 +184,11 @@ export interface DeriveTouchSchemeOptions {
     reserved: ReadonlySet<string>;
     firstPerson: boolean;
     config?: TouchControlsConfig | false;
+    /** Active control context (see {@link TouchControlsConfig.modes}); null/unknown falls back to the base config. */
+    mode?: string | null;
 }
 /**
  * Null means "render no touch controls" — either the game opted out or there
  * is nothing to synthesize.
  */
-export declare function deriveTouchScheme(input: ActionCodesMap | undefined, { reserved, firstPerson, config }: DeriveTouchSchemeOptions): TouchScheme | null;
+export declare function deriveTouchScheme(input: ActionCodesMap | undefined, { reserved, firstPerson, config: rawConfig, mode }: DeriveTouchSchemeOptions): TouchScheme | null;

package/dist/input/touchScheme.js

@@ -44,6 +44,15 @@ export const TOUCH_STYLE_OPTIONS = [
 ];
 /** Skin used when neither the game nor the player picks one. */
 export const DEFAULT_TOUCH_STYLE = "glass";
+/** Every joystick variant id, in menu order. */
+export const TOUCH_JOYSTICK_VARIANTS = ["fixed", "floating"];
+/** Joystick variants as `{ value, label }` rows for the Settings → Controls selector. */
+export const TOUCH_JOYSTICK_VARIANT_OPTIONS = [
+    { value: "floating", label: "Floating (under your thumb)" },
+    { value: "fixed", label: "Fixed" },
+];
+/** Variant used when the player has not picked one. */
+export const DEFAULT_TOUCH_JOYSTICK_VARIANT = "floating";
 const DEFAULT_LOOK_SENSITIVITY = 0.005;
 const DEFAULT_TOUCH_LAYOUT = {
     movement: "bottom-left",
@@ -175,11 +184,27 @@ function gestureActions(gestures) {
     }
     return used;
 }
+/** Resolve the effective config for a mode: mode fields replace base fields; the base is the default mode. */
+function resolveModeConfig(config, mode) {
+    if (config === false || config === undefined || mode === null || mode === undefined)
+        return config;
+    const active = config.modes?.[mode];
+    if (active === undefined)
+        return config;
+    const { modes: _modes, ...base } = config;
+    return { ...base, ...active };
+}
+/**
+ * Auto-derived button count past which the dock stops being playable — two full thumb arcs. A
+ * curated `touch.buttons` list may exceed it deliberately; blind derivation may not.
+ */
+const DERIVED_BUTTON_BUDGET = 8;
 /**
  * Null means "render no touch controls" — either the game opted out or there
  * is nothing to synthesize.
  */
-export function deriveTouchScheme(input, { reserved, firstPerson, config }) {
+export function deriveTouchScheme(input, { reserved, firstPerson, config: rawConfig, mode }) {
+    const config = resolveModeConfig(rawConfig, mode);
     if (config === false)
         return null;
     const actions = Object.keys(input ?? {});
@@ -246,6 +271,11 @@ export function deriveTouchScheme(input, { reserved, firstPerson, config }) {
             anchor: null,
             image: null,
         }));
+        if (buttons.length > DERIVED_BUTTON_BUDGET) {
+            console.warn(`[jgengine:touch] derived ${buttons.length} on-screen buttons (${buttons
+                .map((button) => button.action)
+                .join(", ")}) — more than a thumb can reach. Curate touch.buttons, hide actions with touch.hidden, or split contexts with touch.modes.`);
+        }
     }
     const look = config?.look ?? firstPerson;
     if (joystick === null && buttons.length === 0 && gestures === null && !look)

package/dist/interaction/promptRegistry.d.ts

@@ -0,0 +1,78 @@
+import { type PositionedPrompt, type PromptPoint } from "./proximityPrompt.js";
+/**
+ * A partial edit applied to an already-registered {@link PositionedPrompt} by
+ * {@link PromptRegistry.update}. Any subset of the mutable fields — everything
+ * but the stable `id` — may be supplied; omitted fields keep their prior value.
+ */
+export type PositionedPromptPatch = Partial<Omit<PositionedPrompt, "id">>;
+/**
+ * The serializable shape {@link PromptRegistry.snapshot} returns and
+ * {@link PromptRegistry.restore} consumes: the full set of positioned prompts
+ * (in registration order) plus the id of the prompt that was active when the
+ * snapshot was taken. Prompt display/command payloads are free strings and ids —
+ * keep them serializable and this round-trips through a save cleanly.
+ */
+export interface PromptRegistrySnapshot {
+    /** Every registered prompt, in registration order (tie-break order for resolve). */
+    prompts: readonly PositionedPrompt[];
+    /** Id of the active prompt at snapshot time, or `null` if none was active. */
+    activeId: string | null;
+}
+/**
+ * A live, observable set of interaction prompts that OWNS the registered
+ * {@link PositionedPrompt}s and tracks which one is active for a player. It is a
+ * thin stateful layer over {@link resolveActivePrompt}: registration/order lives
+ * here, the nearest-within-radius / higher-priority selection stays in the pure
+ * resolver. {@link resolve} is the per-frame hot path — call it as the player
+ * moves; subscribers fire only when the active prompt actually CHANGES.
+ */
+export interface PromptRegistry {
+    /**
+     * Add (or replace, by id) a positioned prompt. Replacing an existing id keeps
+     * its registration slot so tie-break order is stable. Does not re-resolve on
+     * its own — the next {@link resolve} picks up the change.
+     */
+    register(prompt: PositionedPrompt): void;
+    /**
+     * Patch a registered prompt in place. No-op if `id` is unknown. Only the fields
+     * present in `patch` change; the rest are preserved.
+     */
+    update(id: string, patch: PositionedPromptPatch): void;
+    /** Remove the prompt with this id, if present. Returns whether one was removed. */
+    unregister(id: string): boolean;
+    /** Remove every prompt and clear the active selection. */
+    clear(): void;
+    /** All registered prompts in registration order (do not mutate the returned array). */
+    all(): readonly PositionedPrompt[];
+    /**
+     * Resolve the active prompt for a player at `playerPosition` by delegating to
+     * {@link resolveActivePrompt}, cache its id, and notify subscribers only when
+     * the active prompt changed since the last call — so a HUD bound to this
+     * registry re-renders on transitions, not every frame. Returns the active
+     * prompt or `null`.
+     */
+    resolve(playerPosition: PromptPoint): PositionedPrompt | null;
+    /** The prompt selected by the most recent {@link resolve}, or `null`. */
+    active(): PositionedPrompt | null;
+    /** Observe active-prompt changes (resolve transitions, clear, restore). Returns an unsubscribe fn. */
+    subscribe(listener: () => void): () => void;
+    /** Serializable state for a save. */
+    snapshot(): PromptRegistrySnapshot;
+    /** Restore prompts + active id from a {@link PromptRegistrySnapshot}. */
+    restore(snapshot: PromptRegistrySnapshot): void;
+}
+/**
+ * Create a live, observable interaction-prompt registry over the pure
+ * {@link resolveActivePrompt} resolver. Register positioned "press E" prompts,
+ * `resolve(playerPosition)` each frame as the hero moves, and read `active()` —
+ * the nearest strictly-in-range prompt (higher `priority` beats closer). The set
+ * is owned here (register/update/unregister/clear/all); selection stays pure.
+ * Subscribers are notified only when the active prompt *changes*, so a HUD does
+ * not thrash per frame, and `snapshot`/`restore` round-trip the prompts plus the
+ * active id through a save (display payloads are free strings/ids the game owns —
+ * the registry never branches on their meaning). Allocation-aware: `all()` and
+ * `resolve()` reuse a cached array instead of rebuilding per call.
+ *
+ * @capability interaction-prompt observable nearest-interactable prompt registry over the proximity-prompt resolver — register/resolve/active with priority+range and change-notified snapshot/restore
+ */
+export declare function createPromptRegistry(): PromptRegistry;

package/dist/interaction/promptRegistry.js

@@ -0,0 +1,130 @@
+import { resolveActivePrompt, } from "./proximityPrompt.js";
+/** Structural copy of a positioned prompt so external mutation can't corrupt registry state. */
+function clonePrompt(prompt) {
+    const copy = {
+        id: prompt.id,
+        position: { x: prompt.position.x, z: prompt.position.z },
+        prompt: {
+            radius: prompt.prompt.radius,
+            display: { ...prompt.prompt.display },
+            invoke: prompt.prompt.invoke === null ? null : { ...prompt.prompt.invoke },
+        },
+    };
+    if (prompt.priority !== undefined)
+        copy.priority = prompt.priority;
+    return copy;
+}
+/**
+ * Create a live, observable interaction-prompt registry over the pure
+ * {@link resolveActivePrompt} resolver. Register positioned "press E" prompts,
+ * `resolve(playerPosition)` each frame as the hero moves, and read `active()` —
+ * the nearest strictly-in-range prompt (higher `priority` beats closer). The set
+ * is owned here (register/update/unregister/clear/all); selection stays pure.
+ * Subscribers are notified only when the active prompt *changes*, so a HUD does
+ * not thrash per frame, and `snapshot`/`restore` round-trip the prompts plus the
+ * active id through a save (display payloads are free strings/ids the game owns —
+ * the registry never branches on their meaning). Allocation-aware: `all()` and
+ * `resolve()` reuse a cached array instead of rebuilding per call.
+ *
+ * @capability interaction-prompt observable nearest-interactable prompt registry over the proximity-prompt resolver — register/resolve/active with priority+range and change-notified snapshot/restore
+ */
+export function createPromptRegistry() {
+    // Insertion-ordered store; Map preserves registration order for resolve tie-breaks.
+    const prompts = new Map();
+    const listeners = new Set();
+    // Cached view of prompts.values(), rebuilt lazily only after a mutation, so the
+    // per-frame resolve() does not allocate a fresh array each call.
+    let listCache = null;
+    let activeId = null;
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    function invalidate() {
+        listCache = null;
+    }
+    function list() {
+        if (listCache === null)
+            listCache = [...prompts.values()];
+        return listCache;
+    }
+    return {
+        register(prompt) {
+            prompts.set(prompt.id, clonePrompt(prompt));
+            invalidate();
+        },
+        update(id, patch) {
+            const existing = prompts.get(id);
+            if (existing === undefined)
+                return;
+            const merged = clonePrompt(existing);
+            if (patch.position !== undefined)
+                merged.position = { x: patch.position.x, z: patch.position.z };
+            if (patch.priority !== undefined)
+                merged.priority = patch.priority;
+            if (patch.prompt !== undefined) {
+                merged.prompt = {
+                    radius: patch.prompt.radius,
+                    display: { ...patch.prompt.display },
+                    invoke: patch.prompt.invoke === null ? null : { ...patch.prompt.invoke },
+                };
+            }
+            prompts.set(id, merged);
+            invalidate();
+        },
+        unregister(id) {
+            const removed = prompts.delete(id);
+            if (removed) {
+                invalidate();
+                if (activeId === id) {
+                    activeId = null;
+                    notify();
+                }
+            }
+            return removed;
+        },
+        clear() {
+            if (prompts.size === 0 && activeId === null)
+                return;
+            prompts.clear();
+            invalidate();
+            if (activeId !== null) {
+                activeId = null;
+                notify();
+            }
+        },
+        all() {
+            return list();
+        },
+        resolve(playerPosition) {
+            const next = resolveActivePrompt(playerPosition, list());
+            const nextId = next === null ? null : next.id;
+            if (nextId !== activeId) {
+                activeId = nextId;
+                notify();
+            }
+            return next;
+        },
+        active() {
+            return activeId === null ? null : prompts.get(activeId) ?? null;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        snapshot() {
+            return {
+                prompts: [...prompts.values()].map(clonePrompt),
+                activeId,
+            };
+        },
+        restore(snapshot) {
+            prompts.clear();
+            for (const prompt of snapshot.prompts)
+                prompts.set(prompt.id, clonePrompt(prompt));
+            invalidate();
+            activeId = snapshot.activeId !== null && prompts.has(snapshot.activeId) ? snapshot.activeId : null;
+            notify();
+        },
+    };
+}

package/dist/inventory/storageTier.js

@@ -1,3 +1,4 @@
+import { resolveRng } from "../random/resolveRng.js";
 export function tierOf(tiers, inventoryId) {
     return tiers[inventoryId] ?? "carried";
 }
@@ -59,7 +60,7 @@ function resolveDelay(delay, rng) {
     const [min, max] = delay;
     return min + rng() * (max - min);
 }
-export function insureLost(lost, policy, userId, now, rng = Math.random) {
+export function insureLost(lost, policy, userId, now, rng) {
     const items = lost.filter((stack) => policy.isInsured(stack.itemId));
     if (items.length === 0)
         return null;
@@ -67,7 +68,7 @@ export function insureLost(lost, policy, userId, now, rng = Math.random) {
         userId,
         inventoryId: policy.returnInventoryId,
         items,
-        deliverAt: now + resolveDelay(policy.delaySeconds, rng),
+        deliverAt: now + resolveDelay(policy.delaySeconds, resolveRng(rng, "scheduleDelivery")),
     };
 }
 export function resolveConsolation(policy, partition) {

package/dist/meta/changelog.d.ts

@@ -1,5 +1,5 @@
 /** Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating. */
-export declare const VERSION = "0.14.0";
+export declare const VERSION = "0.15.0-next.0";
 /** One release's migrate steps plus added/changed/removed notes (typed mirror of CHANGELOG.md). */
 export interface ChangelogEntry {
     migrate: readonly string[];

package/dist/meta/changelog.js

@@ -1,5 +1,5 @@
 /** Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating. */
-export const VERSION = "0.14.0";
+export const VERSION = "0.15.0-next.0";
 /** Per-version engine changelog keyed by semver string (e.g. `"0.10.0"`). */
 export const CHANGELOG = {
     "0.14.0": {