@jgengine/core 0.6.0 → 0.7.0

package/dist/input/axisInput.d.ts

@@ -0,0 +1,43 @@
+export interface AxisInput {
+    throttle: number;
+    brake: number;
+    steer: number;
+    handbrake: number;
+}
+export declare const NEUTRAL_AXIS: AxisInput;
+export type AxisName = keyof AxisInput;
+export interface AxisBinding {
+    positive: readonly string[];
+    negative?: readonly string[];
+}
+export type AxisBindingMap = Record<AxisName, AxisBinding>;
+export interface AxisChannelConfig {
+    bindings: AxisBindingMap;
+    smoothing?: number;
+}
+export interface AxisRange {
+    min: number;
+    max: number;
+}
+export declare const AXIS_RANGE: Record<AxisName, AxisRange>;
+export declare function clampAxis(value: number, range: AxisRange): number;
+export declare function rampToward(current: number, target: number, rate: number, dt: number): 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.
+ */
+export declare class AxisChannel {
+    private readonly bindings;
+    private readonly smoothing;
+    private readonly current;
+    private readonly overrides;
+    constructor(config: AxisChannelConfig);
+    setAnalog(axis: AxisName, value: number): void;
+    clearAnalog(axis: AxisName): void;
+    reset(): void;
+    get value(): AxisInput;
+    sample(dt: number, isDown: (code: string) => boolean): AxisInput;
+}
+export declare const DRIVE_AXIS_BINDINGS: AxisBindingMap;

package/dist/input/axisInput.js

@@ -0,0 +1,70 @@
+export const NEUTRAL_AXIS = { throttle: 0, brake: 0, steer: 0, handbrake: 0 };
+export const AXIS_RANGE = {
+    throttle: { min: 0, max: 1 },
+    brake: { min: 0, max: 1 },
+    steer: { min: -1, max: 1 },
+    handbrake: { min: 0, max: 1 },
+};
+export function clampAxis(value, range) {
+    return value < range.min ? range.min : value > range.max ? range.max : value;
+}
+export function rampToward(current, target, rate, dt) {
+    if (!Number.isFinite(rate))
+        return target;
+    const delta = target - current;
+    const step = rate * dt;
+    if (Math.abs(delta) <= step)
+        return target;
+    return current + Math.sign(delta) * step;
+}
+function digitalTarget(binding, isDown) {
+    const positive = binding.positive.some(isDown) ? 1 : 0;
+    const negative = binding.negative !== undefined && binding.negative.some(isDown) ? 1 : 0;
+    return positive - negative;
+}
+/**
+ * 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.
+ */
+export class AxisChannel {
+    bindings;
+    smoothing;
+    current = { ...NEUTRAL_AXIS };
+    overrides = {};
+    constructor(config) {
+        this.bindings = config.bindings;
+        this.smoothing = config.smoothing ?? 6;
+    }
+    setAnalog(axis, value) {
+        this.overrides[axis] = clampAxis(value, AXIS_RANGE[axis]);
+    }
+    clearAnalog(axis) {
+        delete this.overrides[axis];
+    }
+    reset() {
+        this.current.throttle = 0;
+        this.current.brake = 0;
+        this.current.steer = 0;
+        this.current.handbrake = 0;
+    }
+    get value() {
+        return this.current;
+    }
+    sample(dt, isDown) {
+        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);
+            this.current[axis] = clampAxis(rampToward(this.current[axis], target, this.smoothing, dt), range);
+        }
+        return this.current;
+    }
+}
+export const DRIVE_AXIS_BINDINGS = {
+    throttle: { positive: ["KeyW", "ArrowUp"] },
+    brake: { positive: ["KeyS", "ArrowDown"] },
+    steer: { positive: ["KeyD", "ArrowRight"], negative: ["KeyA", "ArrowLeft"] },
+    handbrake: { positive: ["Space"] },
+};

package/dist/input/pointer.d.ts

@@ -0,0 +1,24 @@
+import type { Aim } from "../scene/spatial.js";
+export type PointerVec3 = readonly [number, number, number];
+/**
+ * Renderer-free result of a screen→world raycast. The shell's pointer service
+ * produces this from the cursor; core-side gameplay (item.use aim, click-to-move,
+ * ground-target abilities, pings) consumes it without touching three.js.
+ */
+export interface PointerHit {
+    /** World-space point under the cursor (surface or ground plane). */
+    point: PointerVec3;
+    /** World-space surface normal at the hit; `[0, 1, 0]` for the ground plane. */
+    normal: PointerVec3;
+    /** Topmost scene-entity instance id under the cursor, or null over open ground. */
+    entity: string | null;
+    /** Topmost scene-object instance id under the cursor, or null. */
+    object: string | null;
+}
+export type PointerButton = "primary" | "secondary" | "middle";
+/** Build an `origin → point` aim for `item.use` / projectiles, firing toward the cursor. */
+export declare function aimToPoint(origin: PointerVec3, point: PointerVec3): Aim;
+/** The move-to target of a pointer hit — sugar over `hit.point`. */
+export declare function moveTargetFromHit(hit: PointerHit): PointerVec3;
+/** Project a pointer hit onto the XZ plane for navmesh routing (`findPath` takes `[x, z]`). */
+export declare function groundOf(hit: PointerHit): readonly [number, number];

package/dist/input/pointer.js

@@ -0,0 +1,17 @@
+/** Build an `origin → point` aim for `item.use` / projectiles, firing toward the cursor. */
+export function aimToPoint(origin, point) {
+    const dx = point[0] - origin[0];
+    const dy = point[1] - origin[1];
+    const dz = point[2] - origin[2];
+    const length = Math.hypot(dx, dy, dz);
+    const direction = length < 1e-9 ? [0, 0, 1] : [dx / length, dy / length, dz / length];
+    return { origin, direction };
+}
+/** The move-to target of a pointer hit — sugar over `hit.point`. */
+export function moveTargetFromHit(hit) {
+    return hit.point;
+}
+/** Project a pointer hit onto the XZ plane for navmesh routing (`findPath` takes `[x, z]`). */
+export function groundOf(hit) {
+    return [hit.point[0], hit.point[2]];
+}

package/dist/interaction/contextMenu.d.ts

@@ -0,0 +1,30 @@
+export type ContextTargetKind = "entity" | "object";
+/** One right-click verb: a label plus the command it dispatches (walk-then-act supported by args). */
+export interface ContextVerb {
+    label: string;
+    command: string;
+    args?: Record<string, unknown>;
+    /** Greyed-out and non-dispatchable when true (e.g. requirement unmet). */
+    disabled?: boolean;
+}
+export declare function contextVerb(label: string, command: string, args?: Record<string, unknown>): ContextVerb;
+export interface ContextMenu {
+    kind: ContextTargetKind;
+    targetId: string;
+    /** World point the click landed on, forwarded to dispatched commands for walk-then-act. */
+    point?: readonly [number, number, number];
+    verbs: readonly ContextVerb[];
+}
+export interface BuildContextMenuInput {
+    kind: ContextTargetKind;
+    targetId: string;
+    verbs: readonly ContextVerb[] | undefined;
+    point?: readonly [number, number, number];
+}
+/** Assemble a menu from a target's catalog verbs; null when the target lists none. */
+export declare function buildContextMenu(input: BuildContextMenuInput): ContextMenu | null;
+/**
+ * Command input a chosen verb dispatches: the verb's own args, plus the target id and
+ * the world point, so a single handler can walk the actor to the target then perform it.
+ */
+export declare function contextVerbInput(menu: ContextMenu, verb: ContextVerb): Record<string, unknown>;

package/dist/interaction/contextMenu.js

@@ -0,0 +1,22 @@
+export function contextVerb(label, command, args) {
+    return args === undefined ? { label, command } : { label, command, args };
+}
+/** Assemble a menu from a target's catalog verbs; null when the target lists none. */
+export function buildContextMenu(input) {
+    if (input.verbs === undefined || input.verbs.length === 0)
+        return null;
+    const menu = { kind: input.kind, targetId: input.targetId, verbs: input.verbs };
+    if (input.point !== undefined)
+        menu.point = input.point;
+    return menu;
+}
+/**
+ * Command input a chosen verb dispatches: the verb's own args, plus the target id and
+ * the world point, so a single handler can walk the actor to the target then perform it.
+ */
+export function contextVerbInput(menu, verb) {
+    const base = { ...verb.args, target: menu.targetId, targetKind: menu.kind };
+    if (menu.point !== undefined)
+        base.point = menu.point;
+    return base;
+}

package/dist/interaction/qte.d.ts

@@ -0,0 +1,20 @@
+export interface QteStep {
+    id: string;
+    action: string;
+    windowStart: number;
+    windowEnd: number;
+}
+export interface QteInputEvent {
+    action: string;
+    at: number;
+}
+export type QteOutcome = {
+    status: "success";
+} | {
+    status: "fail";
+    atStep: string;
+    reason: "missed-window" | "wrong-action" | "too-early";
+};
+export declare function evaluateQteSequence(steps: readonly QteStep[], inputs: readonly QteInputEvent[]): QteOutcome;
+export declare function pendingQteStep(steps: readonly QteStep[], elapsedSeconds: number): QteStep | null;
+export declare function qteProgress(steps: readonly QteStep[], elapsedSeconds: number): number;

package/dist/interaction/qte.js

@@ -0,0 +1,24 @@
+export function evaluateQteSequence(steps, inputs) {
+    for (let index = 0; index < steps.length; index += 1) {
+        const step = steps[index];
+        const input = inputs[index];
+        if (input === undefined)
+            return { status: "fail", atStep: step.id, reason: "missed-window" };
+        if (input.at < step.windowStart)
+            return { status: "fail", atStep: step.id, reason: "too-early" };
+        if (input.at > step.windowEnd)
+            return { status: "fail", atStep: step.id, reason: "missed-window" };
+        if (input.action !== step.action)
+            return { status: "fail", atStep: step.id, reason: "wrong-action" };
+    }
+    return { status: "success" };
+}
+export function pendingQteStep(steps, elapsedSeconds) {
+    return (steps.find((step) => elapsedSeconds >= step.windowStart && elapsedSeconds <= step.windowEnd) ?? null);
+}
+export function qteProgress(steps, elapsedSeconds) {
+    if (steps.length === 0)
+        return 1;
+    const passed = steps.filter((step) => elapsedSeconds > step.windowEnd).length;
+    return passed / steps.length;
+}

package/dist/interaction/skillCheck.d.ts

@@ -0,0 +1,20 @@
+export interface SkillCheckZone {
+    start: number;
+    end: number;
+}
+export interface SkillCheckConfig {
+    trackWidth: number;
+    zone: SkillCheckZone;
+    markerPeriod: number;
+    window: number;
+    zoneDriftPerSecond?: number;
+}
+export interface SkillCheckResult {
+    success: boolean;
+    timedOut: boolean;
+    markerPosition: number;
+    zone: SkillCheckZone;
+}
+export declare function skillCheckMarkerPosition(config: SkillCheckConfig, elapsedSeconds: number): number;
+export declare function skillCheckZoneAt(config: SkillCheckConfig, elapsedSeconds: number): SkillCheckZone;
+export declare function evaluateSkillCheck(config: SkillCheckConfig, elapsedSeconds: number): SkillCheckResult;

package/dist/interaction/skillCheck.js

@@ -0,0 +1,26 @@
+function bounce(t, period, max) {
+    if (period <= 0 || max <= 0)
+        return 0;
+    const cycle = max * 2;
+    const phase = ((t % period) / period) * cycle;
+    return phase <= max ? phase : cycle - phase;
+}
+export function skillCheckMarkerPosition(config, elapsedSeconds) {
+    return bounce(Math.max(0, elapsedSeconds), config.markerPeriod, config.trackWidth);
+}
+export function skillCheckZoneAt(config, elapsedSeconds) {
+    const drift = config.zoneDriftPerSecond ?? 0;
+    if (drift === 0)
+        return config.zone;
+    const width = config.zone.end - config.zone.start;
+    const travel = Math.max(0, config.trackWidth - width);
+    const start = bounce(Math.max(0, elapsedSeconds) * Math.abs(drift), config.markerPeriod, travel);
+    return { start, end: start + width };
+}
+export function evaluateSkillCheck(config, elapsedSeconds) {
+    const timedOut = elapsedSeconds > config.window;
+    const markerPosition = skillCheckMarkerPosition(config, elapsedSeconds);
+    const zone = skillCheckZoneAt(config, elapsedSeconds);
+    const inZone = markerPosition >= zone.start && markerPosition <= zone.end;
+    return { success: !timedOut && inZone, timedOut, markerPosition, zone };
+}

package/dist/inventory/shapedGrid.d.ts

@@ -0,0 +1,56 @@
+export type Cell = readonly [number, number];
+export type Footprint = readonly Cell[];
+export type Rotation = 0 | 1 | 2 | 3;
+export interface ShapedItem<T> {
+    id: string;
+    value: T;
+    footprint: Footprint;
+}
+export interface Placement<T> {
+    id: string;
+    value: T;
+    footprint: Footprint;
+    origin: Cell;
+    rotation: Rotation;
+}
+export interface ShapedGrid<T> {
+    readonly width: number;
+    readonly height: number;
+    readonly placements: readonly Placement<T>[];
+}
+export type ShapedRejection = "out-of-bounds" | "overlap" | "duplicate-id" | "unknown-id";
+export interface ShapedPlaceResult<T> {
+    status: "ok";
+    grid: ShapedGrid<T>;
+}
+export interface ShapedRejected {
+    status: "rejected";
+    reason: ShapedRejection;
+    detail?: string;
+}
+export type ShapedResult<T> = ShapedPlaceResult<T> | ShapedRejected;
+export declare function normalizeFootprint(footprint: Footprint): Footprint;
+export declare function rotateFootprint(footprint: Footprint, rotation: Rotation): Footprint;
+export declare function occupiedCells(footprint: Footprint, origin: Cell, rotation: Rotation): Cell[];
+export declare function createShapedGrid<T>(width: number, height: number): ShapedGrid<T>;
+export declare function canPlace<T>(grid: ShapedGrid<T>, footprint: Footprint, origin: Cell, rotation: Rotation, ignoreId?: string): ShapedRejection | null;
+export declare function placeShaped<T>(grid: ShapedGrid<T>, item: ShapedItem<T>, origin: Cell, rotation?: Rotation): ShapedResult<T>;
+export declare function removeShaped<T>(grid: ShapedGrid<T>, id: string): ShapedResult<T>;
+export declare function moveShaped<T>(grid: ShapedGrid<T>, id: string, origin: Cell, rotation?: Rotation): ShapedResult<T>;
+export declare function cellOccupant<T>(grid: ShapedGrid<T>, cell: Cell): string | null;
+export interface GridAdjacencyQuery {
+    cellsOf(id: string): readonly Cell[];
+    neighborsOf(id: string): readonly string[];
+    touching(idA: string, idB: string): boolean;
+    adjacentCells(cells: readonly Cell[]): readonly Cell[];
+}
+export declare function gridAdjacencyQuery<T>(grid: ShapedGrid<T>, options?: {
+    diagonal?: boolean;
+}): GridAdjacencyQuery;
+export declare function cellFromPoint(point: {
+    x: number;
+    y: number;
+}, cellSize: number, gridOrigin?: {
+    x: number;
+    y: number;
+}): Cell;

package/dist/inventory/shapedGrid.js

@@ -0,0 +1,176 @@
+function cellKey(cell) {
+    return `${cell[0]},${cell[1]}`;
+}
+export function normalizeFootprint(footprint) {
+    if (footprint.length === 0)
+        return [];
+    let minC = Infinity;
+    let minR = Infinity;
+    for (const [c, r] of footprint) {
+        if (c < minC)
+            minC = c;
+        if (r < minR)
+            minR = r;
+    }
+    const shifted = footprint.map(([c, r]) => [c - minC, r - minR]);
+    shifted.sort((a, b) => (a[1] === b[1] ? a[0] - b[0] : a[1] - b[1]));
+    const seen = new Set();
+    const out = [];
+    for (const cell of shifted) {
+        const key = cellKey(cell);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(cell);
+        }
+    }
+    return out;
+}
+export function rotateFootprint(footprint, rotation) {
+    const turns = ((rotation % 4) + 4) % 4;
+    let cells = footprint.map(([c, r]) => [c, r]);
+    for (let i = 0; i < turns; i++) {
+        cells = cells.map(([c, r]) => [-r, c]);
+    }
+    return normalizeFootprint(cells);
+}
+export function occupiedCells(footprint, origin, rotation) {
+    const rotated = rotateFootprint(footprint, rotation);
+    return rotated.map(([c, r]) => [c + origin[0], r + origin[1]]);
+}
+export function createShapedGrid(width, height) {
+    if (width <= 0 || height <= 0)
+        throw new Error("shaped grid needs positive dimensions");
+    return { width, height, placements: [] };
+}
+function inBounds(grid, cells) {
+    return cells.every(([c, r]) => c >= 0 && r >= 0 && c < grid.width && r < grid.height);
+}
+function occupancyMap(grid, ignoreId) {
+    const map = new Map();
+    for (const placement of grid.placements) {
+        if (placement.id === ignoreId)
+            continue;
+        for (const cell of occupiedCells(placement.footprint, placement.origin, placement.rotation)) {
+            map.set(cellKey(cell), placement.id);
+        }
+    }
+    return map;
+}
+export function canPlace(grid, footprint, origin, rotation, ignoreId) {
+    const cells = occupiedCells(footprint, origin, rotation);
+    if (!inBounds(grid, cells))
+        return "out-of-bounds";
+    const occupied = occupancyMap(grid, ignoreId);
+    for (const cell of cells) {
+        if (occupied.has(cellKey(cell)))
+            return "overlap";
+    }
+    return null;
+}
+export function placeShaped(grid, item, origin, rotation = 0) {
+    if (grid.placements.some((p) => p.id === item.id)) {
+        return { status: "rejected", reason: "duplicate-id", detail: item.id };
+    }
+    const rejection = canPlace(grid, item.footprint, origin, rotation);
+    if (rejection !== null)
+        return { status: "rejected", reason: rejection };
+    const placement = {
+        id: item.id,
+        value: item.value,
+        footprint: item.footprint,
+        origin,
+        rotation,
+    };
+    return { status: "ok", grid: { ...grid, placements: [...grid.placements, placement] } };
+}
+export function removeShaped(grid, id) {
+    if (!grid.placements.some((p) => p.id === id)) {
+        return { status: "rejected", reason: "unknown-id", detail: id };
+    }
+    return { status: "ok", grid: { ...grid, placements: grid.placements.filter((p) => p.id !== id) } };
+}
+export function moveShaped(grid, id, origin, rotation) {
+    const existing = grid.placements.find((p) => p.id === id);
+    if (existing === undefined)
+        return { status: "rejected", reason: "unknown-id", detail: id };
+    const nextRotation = rotation ?? existing.rotation;
+    const rejection = canPlace(grid, existing.footprint, origin, nextRotation, id);
+    if (rejection !== null)
+        return { status: "rejected", reason: rejection };
+    return {
+        status: "ok",
+        grid: {
+            ...grid,
+            placements: grid.placements.map((p) => p.id === id ? { ...p, origin, rotation: nextRotation } : p),
+        },
+    };
+}
+export function cellOccupant(grid, cell) {
+    return occupancyMap(grid).get(cellKey(cell)) ?? null;
+}
+const ORTHOGONAL = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+];
+const DIAGONAL = [
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1],
+];
+export function gridAdjacencyQuery(grid, options = {}) {
+    const directions = options.diagonal ? [...ORTHOGONAL, ...DIAGONAL] : ORTHOGONAL;
+    const cellsById = new Map();
+    const owner = new Map();
+    for (const placement of grid.placements) {
+        const cells = occupiedCells(placement.footprint, placement.origin, placement.rotation);
+        cellsById.set(placement.id, cells);
+        for (const cell of cells)
+            owner.set(cellKey(cell), placement.id);
+    }
+    const cellsOf = (id) => cellsById.get(id) ?? [];
+    const neighborsOf = (id) => {
+        const found = new Set();
+        for (const cell of cellsOf(id)) {
+            for (const [dc, dr] of directions) {
+                const key = cellKey([cell[0] + dc, cell[1] + dr]);
+                const other = owner.get(key);
+                if (other !== undefined && other !== id)
+                    found.add(other);
+            }
+        }
+        return [...found];
+    };
+    return {
+        cellsOf,
+        neighborsOf,
+        touching: (idA, idB) => neighborsOf(idA).includes(idB),
+        adjacentCells(cells) {
+            const own = new Set(cells.map(cellKey));
+            const found = new Set();
+            const out = [];
+            for (const cell of cells) {
+                for (const [dc, dr] of directions) {
+                    const target = [cell[0] + dc, cell[1] + dr];
+                    const key = cellKey(target);
+                    if (own.has(key) || found.has(key))
+                        continue;
+                    if (target[0] < 0 || target[1] < 0 || target[0] >= grid.width || target[1] >= grid.height) {
+                        continue;
+                    }
+                    found.add(key);
+                    out.push(target);
+                }
+            }
+            return out;
+        },
+    };
+}
+export function cellFromPoint(point, cellSize, gridOrigin = { x: 0, y: 0 }) {
+    return [
+        Math.floor((point.x - gridOrigin.x) / cellSize),
+        Math.floor((point.y - gridOrigin.y) / cellSize),
+    ];
+}

package/dist/inventory/storageTier.d.ts

@@ -0,0 +1,52 @@
+export type StorageTier = "carried" | "banked";
+export interface ItemStack {
+    itemId: string;
+    count: number;
+}
+export interface ContainerSnapshot {
+    inventoryId: string;
+    tier: StorageTier;
+    items: readonly ItemStack[];
+}
+export interface DeathPartition {
+    kept: readonly ItemStack[];
+    lost: readonly ItemStack[];
+}
+export declare function tierOf(tiers: Record<string, StorageTier>, inventoryId: string): StorageTier;
+export declare function partitionOnDeath(containers: readonly ContainerSnapshot[]): DeathPartition;
+export interface DeliveryEntry {
+    id: string;
+    userId: string;
+    inventoryId: string;
+    items: readonly ItemStack[];
+    deliverAt: number;
+}
+export interface ScheduledDelivery {
+    userId: string;
+    inventoryId: string;
+    items: readonly ItemStack[];
+    deliverAt: number;
+}
+export interface DeliveryQueue {
+    schedule(entry: ScheduledDelivery & {
+        id?: string;
+    }): DeliveryEntry;
+    due(now: number): readonly DeliveryEntry[];
+    claimDue(now: number): readonly DeliveryEntry[];
+    pending(userId?: string): readonly DeliveryEntry[];
+    cancel(id: string): boolean;
+}
+export declare function createDeliveryQueue(): DeliveryQueue;
+export interface InsurancePolicy {
+    isInsured(itemId: string): boolean;
+    returnInventoryId: string;
+    delaySeconds: number | [number, number];
+}
+export declare function insureLost(lost: readonly ItemStack[], policy: InsurancePolicy, userId: string, now: number, rng?: () => number): ScheduledDelivery | null;
+export interface ConsolationPolicy {
+    loadoutId: string;
+    when?: "always" | "if-carried-empty";
+}
+export declare function resolveConsolation(policy: ConsolationPolicy, partition: DeathPartition): {
+    loadoutId: string;
+} | null;

package/dist/inventory/storageTier.js

@@ -0,0 +1,77 @@
+export function tierOf(tiers, inventoryId) {
+    return tiers[inventoryId] ?? "carried";
+}
+function mergeStacks(stacks) {
+    const totals = new Map();
+    for (const stack of stacks)
+        totals.set(stack.itemId, (totals.get(stack.itemId) ?? 0) + stack.count);
+    const out = [];
+    for (const [itemId, count] of totals)
+        if (count > 0)
+            out.push({ itemId, count });
+    return out;
+}
+export function partitionOnDeath(containers) {
+    const kept = [];
+    const lost = [];
+    for (const container of containers) {
+        (container.tier === "banked" ? kept : lost).push(...container.items);
+    }
+    return { kept: mergeStacks(kept), lost: mergeStacks(lost) };
+}
+export function createDeliveryQueue() {
+    const entries = new Map();
+    let counter = 0;
+    return {
+        schedule(entry) {
+            const id = entry.id ?? `delivery_${(counter += 1)}`;
+            const stored = {
+                id,
+                userId: entry.userId,
+                inventoryId: entry.inventoryId,
+                items: entry.items,
+                deliverAt: entry.deliverAt,
+            };
+            entries.set(id, stored);
+            return stored;
+        },
+        due(now) {
+            return [...entries.values()].filter((e) => e.deliverAt <= now);
+        },
+        claimDue(now) {
+            const ready = [...entries.values()].filter((e) => e.deliverAt <= now);
+            for (const entry of ready)
+                entries.delete(entry.id);
+            return ready;
+        },
+        pending(userId) {
+            const all = [...entries.values()];
+            return userId === undefined ? all : all.filter((e) => e.userId === userId);
+        },
+        cancel(id) {
+            return entries.delete(id);
+        },
+    };
+}
+function resolveDelay(delay, rng) {
+    if (typeof delay === "number")
+        return delay;
+    const [min, max] = delay;
+    return min + rng() * (max - min);
+}
+export function insureLost(lost, policy, userId, now, rng = Math.random) {
+    const items = lost.filter((stack) => policy.isInsured(stack.itemId));
+    if (items.length === 0)
+        return null;
+    return {
+        userId,
+        inventoryId: policy.returnInventoryId,
+        items,
+        deliverAt: now + resolveDelay(policy.delaySeconds, rng),
+    };
+}
+export function resolveConsolation(policy, partition) {
+    if (policy.when === "if-carried-empty" && partition.lost.length > 0)
+        return null;
+    return { loadoutId: policy.loadoutId };
+}