@jgengine/core 0.18.1 → 0.21.0

package/dist/game/saveStore.js

@@ -1,47 +1,45 @@
-import { defaultKeyValueStorage } from "./keyValueStore.js";
-function readSafe(storage, key) {
-    if (storage === null)
-        return null;
-    try {
-        return storage.getItem(key);
-    }
-    catch {
-        return null;
-    }
-}
+import { defaultKeyValueStorage, reportStorageFailure } from "./keyValueStore.js";
 /**
  * A {@link SaveBackend} over a synchronous {@link KeyValueStorage} — the
  * browser's `localStorage` by default (offline, on-device saves), a test stub,
- * or `null` for memory-only. Storage errors (quota exceeded, private mode, no
- * DOM) degrade to no-ops, so a save never throws into a game tick.
+ * or `null` for a no-op backend. Default fallback ignores failures; `errorMode: "throw"`
+ * rejects failed operations and unavailable storage, so SaveStore status/onError can report them.
+ * Use {@link memorySaveBackend} for deliberate ephemeral persistence.
  *
  * @capability local-save persist a game to on-device localStorage (offline)
  */
-export function localSaveBackend(storage) {
-    const store = storage === undefined ? defaultKeyValueStorage() : storage;
+export function localSaveBackend(storage, policy = {}) {
+    const resolve = () => {
+        const store = storage === undefined ? defaultKeyValueStorage((error) => { throw error; }) : storage;
+        if (store === null)
+            throw new Error("Local storage is unavailable");
+        return store;
+    };
     return {
-        read: (key) => Promise.resolve(readSafe(store, key)),
-        write: (key, value) => {
-            if (store !== null) {
-                try {
-                    store.setItem(key, value);
-                }
-                catch {
-                    // storage rejected the write; the store keeps the value in memory
-                }
+        async read(key) {
+            try {
+                return resolve().getItem(key);
+            }
+            catch (error) {
+                reportStorageFailure(policy, { operation: "read", key, error });
+                return null;
             }
-            return Promise.resolve();
         },
-        remove: (key) => {
-            if (store !== null) {
-                try {
-                    store.removeItem(key);
-                }
-                catch {
-                    // ignore removal failure
-                }
+        async write(key, value) {
+            try {
+                resolve().setItem(key, value);
+            }
+            catch (error) {
+                reportStorageFailure(policy, { operation: "write", key, error });
+            }
+        },
+        async remove(key) {
+            try {
+                resolve().removeItem(key);
+            }
+            catch (error) {
+                reportStorageFailure(policy, { operation: "remove", key, error });
             }
-            return Promise.resolve();
         },
     };
 }
@@ -143,10 +141,10 @@ export function createSaveStore(config) {
         return parsed;
     }
     async function readSlots() {
+        const raw = await backend.read(indexKey());
+        if (raw === null)
+            return [];
         try {
-            const raw = await backend.read(indexKey());
-            if (raw === null)
-                return [];
             const parsed = JSON.parse(raw);
             return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
         }
@@ -155,26 +153,16 @@ export function createSaveStore(config) {
         }
     }
     async function rememberSlot(slot) {
-        try {
-            const list = await readSlots();
-            if (list.includes(slot))
-                return;
-            await backend.write(indexKey(), JSON.stringify([...list, slot]));
-        }
-        catch (error) {
-            reportError(error);
-        }
+        const list = await readSlots();
+        if (list.includes(slot))
+            return;
+        await backend.write(indexKey(), JSON.stringify([...list, slot]));
     }
     async function forgetSlot(slot) {
-        try {
-            const list = await readSlots();
-            if (!list.includes(slot))
-                return;
-            await backend.write(indexKey(), JSON.stringify(list.filter((entry) => entry !== slot)));
-        }
-        catch (error) {
-            reportError(error);
-        }
+        const list = await readSlots();
+        if (!list.includes(slot))
+            return;
+        await backend.write(indexKey(), JSON.stringify(list.filter((entry) => entry !== slot)));
     }
     function clearTimer() {
         if (pendingTimer !== null) {
@@ -243,7 +231,10 @@ export function createSaveStore(config) {
             firstDirtyAt = null;
             setStatus("idle");
             emit();
-            void rememberSlot(currentSlot);
+            void rememberSlot(currentSlot).catch((error) => {
+                setStatus("error");
+                reportError(error);
+            });
             return current;
         }
         catch (error) {
@@ -298,7 +289,16 @@ export function createSaveStore(config) {
             firstDirtyAt = null;
             return load();
         },
-        slots: readSlots,
+        async slots() {
+            try {
+                return await readSlots();
+            }
+            catch (error) {
+                setStatus("error");
+                reportError(error);
+                return [];
+            }
+        },
         subscribe(listener) {
             listeners.add(listener);
             return () => listeners.delete(listener);

package/dist/game/systemRuntime.d.ts

@@ -15,14 +15,14 @@ export interface InstalledSystems {
     tick(ctx: GameContext, dt: number): void;
     /** Invoke every system's `reset` (scenario/run wipe). */
     reset(ctx: GameContext): void;
-    /** Invoke every system's `dispose` in reverse install order. */
+    /** Retire once in reverse order; finish cleanup before rethrowing the first error. */
     dispose(ctx: GameContext): void;
     /** Run one manual system by id (no-op if missing or not manual). */
     runManual(ctx: GameContext, id: string, dt?: number): void;
 }
 /**
  * Install systems on a live context: `create` → bind events → register save/replicate → `start`.
- * Call once per world boot (from the composed loop's `onInit`).
+ * Call once per world boot. Failed installation retires entered systems and listeners, then rethrows the startup error.
  * @internal
  */
 export declare function installSystems(ctx: GameContext, systems: readonly SystemDefinition[], options?: CompileSystemScheduleOptions & {

package/dist/game/systemRuntime.js

@@ -7,7 +7,7 @@ function resolveModule(spec, ctx) {
 }
 /**
  * Install systems on a live context: `create` → bind events → register save/replicate → `start`.
- * Call once per world boot (from the composed loop's `onInit`).
+ * Call once per world boot. Failed installation retires entered systems and listeners, then rethrows the startup error.
  * @internal
  */
 export function installSystems(ctx, systems, options) {
@@ -16,29 +16,41 @@ export function installSystems(ctx, systems, options) {
     const unsubs = [];
     const intervalAcc = new Map();
     const fixedAcc = new Map();
-    for (const system of list) {
-        system.create?.(ctx);
-    }
-    for (const system of list) {
-        if (system.events !== undefined) {
-            for (const [name, handler] of Object.entries(system.events)) {
-                if (handler === undefined)
-                    continue;
-                const off = ctx.game.events.on(name, ((event) => {
-                    handler(ctx, event);
-                }));
-                unsubs.push(off);
+    const acquired = [];
+    let disposed = false;
+    try {
+        for (const system of list) {
+            acquired.push(system);
+            system.create?.(ctx);
+        }
+        for (const system of list) {
+            if (system.events !== undefined) {
+                for (const [name, handler] of Object.entries(system.events)) {
+                    if (handler === undefined)
+                        continue;
+                    const off = ctx.game.events.on(name, ((event) => {
+                        handler(ctx, event);
+                    }));
+                    unsubs.push(off);
+                }
             }
+            const save = resolveModule(system.save, ctx);
+            if (save !== undefined)
+                options?.modules?.registerSave(save);
+            const replicate = resolveModule(system.replicate, ctx);
+            if (replicate !== undefined)
+                options?.modules?.registerReplicate(replicate);
+        }
+        for (const system of list) {
+            system.start?.(ctx);
         }
-        const save = resolveModule(system.save, ctx);
-        if (save !== undefined)
-            options?.modules?.registerSave(save);
-        const replicate = resolveModule(system.replicate, ctx);
-        if (replicate !== undefined)
-            options?.modules?.registerReplicate(replicate);
     }
-    for (const system of list) {
-        system.start?.(ctx);
+    catch (error) {
+        try {
+            dispose(ctx);
+        }
+        catch { /* The startup error remains the first failure. */ }
+        throw error;
     }
     for (const group of schedule.fixed) {
         fixedAcc.set(group.rate, 0);
@@ -52,7 +64,7 @@ export function installSystems(ctx, systems, options) {
         }
     }
     function tick(ctx, dt) {
-        if (!(dt > 0))
+        if (disposed || !(dt > 0))
             return;
         for (const group of schedule.fixed) {
             const step = 1 / group.rate;
@@ -79,6 +91,8 @@ export function installSystems(ctx, systems, options) {
         }
     }
     function reset(ctx) {
+        if (disposed)
+            return;
         for (const system of list)
             system.reset?.(ctx);
         for (const group of schedule.fixed)
@@ -87,14 +101,33 @@ export function installSystems(ctx, systems, options) {
             intervalAcc.set(interval.id, 0);
     }
     function dispose(ctx) {
-        for (const off of unsubs)
-            off();
+        if (disposed)
+            return;
+        disposed = true;
+        let failure;
+        for (const off of unsubs) {
+            try {
+                off();
+            }
+            catch (error) {
+                failure ??= { error };
+            }
+        }
         unsubs.length = 0;
-        for (let i = list.length - 1; i >= 0; i -= 1) {
-            list[i]?.dispose?.(ctx);
+        for (let i = acquired.length - 1; i >= 0; i -= 1) {
+            try {
+                acquired[i]?.dispose?.(ctx);
+            }
+            catch (error) {
+                failure ??= { error };
+            }
         }
+        if (failure !== undefined)
+            throw failure.error;
     }
     function runManual(ctx, id, dt = 0) {
+        if (disposed)
+            return;
         if (!schedule.manual.includes(id))
             return;
         schedule.systemsById.get(id)?.update?.(ctx, dt);
@@ -119,17 +152,18 @@ export function composeGameLoop(systems, loop, options) {
     if (systems === undefined || systems.length === 0) {
         return loop ?? {};
     }
-    let installed;
+    const retired = new WeakSet();
     const loopBefore = options?.loopBeforeSystems === true;
     return {
         onInit(ctx) {
+            retired.delete(ctx);
             const modules = ctx.game.registerSave !== undefined && ctx.game.registerReplicate !== undefined
                 ? {
                     registerSave: (m) => ctx.game.registerSave(m),
                     registerReplicate: (m) => ctx.game.registerReplicate(m),
                 }
                 : undefined;
-            installed = installSystems(ctx, systems, { ...options, modules });
+            const installed = installSystems(ctx, systems, { ...options, modules });
             installedByCtx.set(ctx, installed);
             loop?.onInit?.(ctx);
         },
@@ -139,10 +173,10 @@ export function composeGameLoop(systems, loop, options) {
         onTick(ctx, dt) {
             if (loopBefore) {
                 loop?.onTick?.(ctx, dt);
-                installed?.tick(ctx, dt);
+                installedByCtx.get(ctx)?.tick(ctx, dt);
             }
             else {
-                installed?.tick(ctx, dt);
+                installedByCtx.get(ctx)?.tick(ctx, dt);
                 loop?.onTick?.(ctx, dt);
             }
         },
@@ -150,13 +184,30 @@ export function composeGameLoop(systems, loop, options) {
             loop?.onPlayerLeave?.(ctx, player);
         },
         onReset(ctx) {
-            installed?.reset(ctx);
+            installedByCtx.get(ctx)?.reset(ctx);
             loop?.onReset?.(ctx);
         },
         onDispose(ctx) {
-            installed?.dispose(ctx);
+            if (retired.has(ctx))
+                return;
+            retired.add(ctx);
+            const installed = installedByCtx.get(ctx);
             installedByCtx.delete(ctx);
-            loop?.onDispose?.(ctx);
+            let failure;
+            try {
+                installed?.dispose(ctx);
+            }
+            catch (error) {
+                failure = { error };
+            }
+            try {
+                loop?.onDispose?.(ctx);
+            }
+            catch (error) {
+                failure ??= { error };
+            }
+            if (failure !== undefined)
+                throw failure.error;
         },
     };
 }

package/dist/game/toasts.d.ts

@@ -15,6 +15,11 @@ export interface Toast<T = string> {
 export declare function appendToast<T>(toasts: readonly Toast<T>[], toast: Toast<T>, cap: number): readonly Toast<T>[];
 /** Drop every toast whose `expiresAt` is at or before `now`. Returns the same array when nothing expired. */
 export declare function pruneToasts<T>(toasts: readonly Toast<T>[], now: number): readonly Toast<T>[];
+/** Plain JSON state of a {@link ToastQueue}: live toasts plus the id counter. */
+export interface ToastQueueState<T = string> {
+    toasts: Toast<T>[];
+    counter: number;
+}
 /** Stateful transient-toast list with a size cap and time-to-live eviction. */
 export interface ToastQueue<T = string> {
     /** Raise a toast at `now` living `ttlSeconds` (falling back to the queue default); returns it. */
@@ -25,6 +30,9 @@ export interface ToastQueue<T = string> {
     list(): readonly Toast<T>[];
     /** Remove all toasts. */
     clear(): void;
+    /** Copies the queue; each toast's `body` is shared, since the queue never mutates it. */
+    snapshot(): ToastQueueState<T>;
+    restore(next: ToastQueueState<T>): void;
 }
 /** Options for {@link createToastQueue}. */
 export interface ToastQueueOptions {

package/dist/game/toasts.js

@@ -40,5 +40,12 @@ export function createToastQueue(options = {}) {
         clear() {
             toasts = [];
         },
+        snapshot() {
+            return { toasts: toasts.map((toast) => ({ ...toast })), counter };
+        },
+        restore(next) {
+            toasts = next.toasts.map((toast) => ({ ...toast }));
+            counter = next.counter;
+        },
     };
 }

package/dist/game/vfxInstance.d.ts

@@ -115,6 +115,15 @@ export interface VfxInstanceStore {
     tick(nowMs?: number): number;
     /** Dispose every instance (scene change / reset), emitting a `stop` op for each. */
     clear(): void;
+    /** Plain JSON copy of every live instance plus the id counter. */
+    snapshot(): VfxInstanceStoreState;
+    /** Replaces the live set: emits `stop` for each current instance, then `upsert` for each restored one. */
+    restore(next: VfxInstanceStoreState): void;
+}
+/** Plain JSON state of a {@link VfxInstanceStore}. */
+export interface VfxInstanceStoreState {
+    instances: VfxInstanceState[];
+    seq: number;
 }
 /** Options for {@link createVfxInstanceStore}. */
 export interface VfxInstanceStoreOptions {

package/dist/game/vfxInstance.js

@@ -92,5 +92,16 @@ export function createVfxInstanceStore(options = {}) {
         for (const id of [...instances.keys()])
             stop(id);
     }
-    return { upsert, update, stop, get, list, count, tick, clear };
+    function snapshot() {
+        return { instances: structuredClone([...instances.values()]), seq };
+    }
+    function restore(next) {
+        clear();
+        seq = next.seq;
+        for (const state of structuredClone(next.instances)) {
+            instances.set(state.id, state);
+            emit({ op: "upsert", id: state.id, instance: state });
+        }
+    }
+    return { upsert, update, stop, get, list, count, tick, clear, snapshot, restore };
 }

package/dist/game/viewports.d.ts

@@ -0,0 +1,43 @@
+import type { ChaseCameraConfig, TopDownCameraConfig } from "./cameraConfig.js";
+/** A screen region as fractions of the canvas, `[x, y, width, height]` in `0..1` with the origin at the top left. */
+export type ViewportRect = readonly [number, number, number, number];
+/** The follow camera an extra viewport runs; the primary seat keeps the game's main camera rig. */
+export interface ViewportCameraConfig {
+    /** Default: `"topDown"` when the game's main rig is top-down, otherwise `"chase"`. */
+    rig?: "chase" | "topDown";
+    chase?: ChaseCameraConfig;
+    topDown?: TopDownCameraConfig;
+}
+/** One viewport: which local seat it shows and where. */
+export interface ViewportDef {
+    /** Local seat id (`"slot:0"`, `"slot:1"`, …) from `localPlayers(ctx)`. */
+    slot: string;
+    rect: ViewportRect;
+    camera?: ViewportCameraConfig;
+}
+/** `defineGame({ viewports })`: split-screen layout for local seats. */
+export interface ViewportsConfig {
+    /** `"auto"` (default) splits the screen evenly across the seats currently joined; a list pins explicit rects. */
+    layout?: "auto" | readonly ViewportDef[];
+    /** Two-seat split: `"vertical"` puts them side by side (default), `"horizontal"` stacks them. */
+    split?: "vertical" | "horizontal";
+    /** Follow camera for seats whose viewport has none. */
+    camera?: ViewportCameraConfig;
+}
+/** A viewport in canvas pixels with a bottom-left origin, ready for `gl.setViewport`/`setScissor`. */
+export interface ViewportPixels {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Even split-screen rects for seats in order: one fills the screen, two split side by side (or stacked),
+ * three put the first on a full-width top half, four make a 2×2 grid, more fill a grid row by row.
+ * @capability split-screen Split the screen into one viewport per local seat, each with its own follow camera.
+ */
+export declare function splitViewports(slots: readonly string[], split?: "vertical" | "horizontal"): ViewportDef[];
+/** The viewports to draw for the seats currently joined: the explicit layout filtered to joined seats, or an even split. */
+export declare function resolveViewports(config: ViewportsConfig | undefined, slots: readonly string[]): ViewportDef[];
+/** Convert a top-left fractional rect into whole canvas pixels with a bottom-left origin; neighbours share edges exactly. */
+export declare function viewportPixels(rect: ViewportRect, width: number, height: number): ViewportPixels;

package/dist/game/viewports.js

@@ -0,0 +1,46 @@
+function gridRects(count) {
+    const columns = Math.ceil(Math.sqrt(count));
+    const rows = Math.ceil(count / columns);
+    const rects = [];
+    for (let index = 0; index < count; index += 1) {
+        const row = Math.floor(index / columns);
+        const inRow = row === rows - 1 ? count - row * columns : columns;
+        const column = index - row * columns;
+        rects.push([column / inRow, row / rows, 1 / inRow, 1 / rows]);
+    }
+    return rects;
+}
+/**
+ * Even split-screen rects for seats in order: one fills the screen, two split side by side (or stacked),
+ * three put the first on a full-width top half, four make a 2×2 grid, more fill a grid row by row.
+ * @capability split-screen Split the screen into one viewport per local seat, each with its own follow camera.
+ */
+export function splitViewports(slots, split = "vertical") {
+    const count = slots.length;
+    let rects;
+    if (count <= 1)
+        rects = [[0, 0, 1, 1]];
+    else if (count === 2) {
+        rects = split === "vertical" ? [[0, 0, 0.5, 1], [0.5, 0, 0.5, 1]] : [[0, 0, 1, 0.5], [0, 0.5, 1, 0.5]];
+    }
+    else if (count === 3)
+        rects = [[0, 0, 1, 0.5], [0, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5]];
+    else
+        rects = gridRects(count);
+    return slots.map((slot, index) => ({ slot, rect: rects[index] }));
+}
+/** The viewports to draw for the seats currently joined: the explicit layout filtered to joined seats, or an even split. */
+export function resolveViewports(config, slots) {
+    const layout = config?.layout ?? "auto";
+    if (layout === "auto")
+        return splitViewports(slots, config?.split);
+    return layout.filter((def) => slots.includes(def.slot));
+}
+/** Convert a top-left fractional rect into whole canvas pixels with a bottom-left origin; neighbours share edges exactly. */
+export function viewportPixels(rect, width, height) {
+    const left = Math.round(rect[0] * width);
+    const right = Math.round((rect[0] + rect[2]) * width);
+    const top = Math.round(rect[1] * height);
+    const bottom = Math.round((rect[1] + rect[3]) * height);
+    return { x: left, y: height - bottom, width: Math.max(1, right - left), height: Math.max(1, bottom - top) };
+}

package/dist/game/worldItem.d.ts

@@ -62,7 +62,6 @@ export declare function selectNearestWorldItem(candidates: readonly {
 /**
  * Spawn and track pickup-able items scattered in the world, including drops that scatter on death.
  *
- * @capability world-drops spawn pickup-able items in the world, including death drops
   * @internal
   */
 export declare function createWorldItemStore(deps: WorldItemStoreDeps): WorldItemStore;
@@ -87,6 +86,11 @@ export interface ResolvedDeathDrops {
   * @internal
   */
 export declare function resolveDeathDrops(drops: readonly Drop[], options: ResolveDeathDropsOptions): ResolvedDeathDrops;
+/**
+ * Per-rarity look of a dropped item: beam, color and label. Set via `defineGame({ worldItem: { rarityStyle } })`.
+ *
+ * @capability loot-beams rarity-colored loot beams and labels on dropped items via defineGame({ worldItem: { rarityStyle, beamHeight } })
+ */
 export interface RarityStyle {
     color?: string;
     beam?: boolean;

package/dist/game/worldItem.js

@@ -39,7 +39,6 @@ export function selectNearestWorldItem(candidates, from, radius) {
 /**
  * Spawn and track pickup-able items scattered in the world, including drops that scatter on death.
  *
- * @capability world-drops spawn pickup-able items in the world, including death drops
   * @internal
   */
 export function createWorldItemStore(deps) {

package/dist/gameplay.d.ts

@@ -31,6 +31,7 @@ export { medalFor, rankLeaderboard, type RankLeaderboardOptions, type RankableRo
 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 { timeScaledRarity, type TimeScaledRarityOptions } from "./game/lootModifiers.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";
@@ -100,5 +101,7 @@ export { createMultiRegionHealth, type MultiRegionHealth } from "./survival/regi
 export { createCommitController } from "./turn/commit.js";
 export { createIntentBoard } from "./turn/intent.js";
 export { createTurnLoop, type TurnLoop } from "./turn/turnLoop.js";
+export { dispatchExpedition, recallExpedition, returnExpeditionNow, settleExpedition, type ExpeditionConfig, type ExpeditionDispatch, type ExpeditionEvent, type ExpeditionHazard, type ExpeditionState, type ExpeditionSupplyRule, } from "./work/expedition.js";
 export { activeJobs, cancelJob, createWorkQueue, enqueue, fifoOrdering, jobById, jobProgress, pauseJob, priorityOrdering, queueSize, queuedJobs, resumeJob, tick, type CancelResult, type EnqueueOptions, type EnqueueResult, type Job, type JobId, type JobOrdering, type JobStatus, type JobValidation, type TickResult, type WorkQueueConfig, type WorkQueueEvent, type WorkQueueState, } from "./work/jobQueue.js";
+export { stationOutputRate, type StaffedStation, type StationRateTuning, type StationWorker, } from "./work/staffedStation.js";
 export { unitTrainingConfig, type ResourceCost, type TrainableUnitDef, type UnitReservation, type UnitSpawnOrder, type UnitTrainingOptions, type UnitTrainingSpec, } from "./work/unitTraining.js";

package/dist/gameplay.js

@@ -31,6 +31,7 @@ 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 { timeScaledRarity } from "./game/lootModifiers.js";
 export { createLootPipeline, defineLootPipeline, } from "./game/lootPipeline.js";
 export { createLootRegistry, lootTable } from "./game/lootTable.js";
 export { resolveOneShotClip } from "./game/modelAnimation.js";
@@ -100,5 +101,7 @@ export { createMultiRegionHealth } from "./survival/regionHealth.js";
 export { createCommitController } from "./turn/commit.js";
 export { createIntentBoard } from "./turn/intent.js";
 export { createTurnLoop } from "./turn/turnLoop.js";
+export { dispatchExpedition, recallExpedition, returnExpeditionNow, settleExpedition, } from "./work/expedition.js";
 export { activeJobs, cancelJob, createWorkQueue, enqueue, fifoOrdering, jobById, jobProgress, pauseJob, priorityOrdering, queueSize, queuedJobs, resumeJob, tick, } from "./work/jobQueue.js";
+export { stationOutputRate, } from "./work/staffedStation.js";
 export { unitTrainingConfig, } from "./work/unitTraining.js";

package/dist/input/actionBindings.d.ts

@@ -34,7 +34,13 @@ export type ActionCodes<TCode extends string = string> = readonly TCode[] | {
     toggle?: readonly TCode[];
     repeatMs?: number;
 };
-/** Maps each game action name to the input codes (hold/toggle keys, repeat rate) that trigger it. */
+/**
+ * Maps each game action name to the input codes (hold/toggle keys, repeat rate) that trigger it. In a
+ * `defineGame({ input })`, pressing an action runs the same-named command with `{ yaw, pitch, aim }`;
+ * `repeatMs` re-fires it while held (automatic weapons).
+ *
+ * @capability fire-input bind a key or mouse button to a named action that runs the same-named command with the aim; repeatMs auto-fires while held
+ */
 export type ActionCodesMap<TAction extends string = string, TCode extends string = string> = Record<TAction, ActionCodes<TCode>>;
 /** @internal */
 export declare function actionRepeatMs(codes: ActionCodes | undefined): number | undefined;
@@ -82,6 +88,14 @@ export interface ActionStateTracker<TAction extends string> {
     wasPressed(action: TAction): boolean;
     endFrame(): void;
     reset(): void;
+    /**
+     * Swap the binding map without dropping what is physically held: a key still down counts toward
+     * whatever action it maps to now, with no fresh press edge. Toggle state survives for actions that
+     * come back later.
+     */
+    rebind(map: ActionStateBindingMap<TAction, string>): void;
+    /** The action names in the current binding map. */
+    actions(): readonly TAction[];
 }
 /** @internal */
 export declare function createActionStateTracker<TAction extends string, TCode extends string = string>(map: ActionStateBindingMap<TAction, TCode>): ActionStateTracker<TAction>;

package/dist/input/actionBindings.js

@@ -179,9 +179,9 @@ function resolveActionBindingModes(config) {
 }
 /** @internal */
 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()]));
+    let actions = Object.keys(map);
+    let modesByAction = new Map(actions.map((action) => [action, resolveActionBindingModes(map[action])]));
+    let heldCodesByAction = new Map(actions.map((action) => [action, new Set()]));
     const toggledActions = new Set();
     const pressedThisFrame = new Set();
     const activeCodes = new Set();
@@ -240,5 +240,16 @@ export function createActionStateTracker(map) {
             pressedThisFrame.clear();
             activeCodes.clear();
         },
+        rebind(next) {
+            actions = Object.keys(next);
+            modesByAction = new Map(actions.map((action) => [action, resolveActionBindingModes(next[action])]));
+            heldCodesByAction = new Map(actions.map((action) => [action, new Set()]));
+            for (const code of activeCodes) {
+                const holdAction = findAction(code, (modes) => modes.hold);
+                if (holdAction !== null)
+                    heldCodesByAction.get(holdAction).add(code);
+            }
+        },
+        actions: () => actions,
     };
 }