@jgengine/core 0.5.0 → 0.7.0

package/dist/item/affix.d.ts

@@ -0,0 +1,54 @@
+export type AffixOp = "add" | "mul";
+export interface AffixDef {
+    id: string;
+    stat: string;
+    op?: AffixOp;
+    roll: number | [number, number];
+    weight: number;
+    namePart?: {
+        position: "prefix" | "suffix";
+        text: string;
+    };
+}
+export interface AffixPool {
+    id: string;
+    affixes: readonly AffixDef[];
+}
+export interface RarityTier {
+    id: string;
+    weight: number;
+    affixCount: number | [number, number];
+    statScale?: number;
+    namePart?: string;
+    pools?: readonly string[];
+}
+export interface ItemBaseDef {
+    id: string;
+    name: string;
+    baseStats: Record<string, number>;
+    pools: readonly string[];
+}
+export interface RollerConfig {
+    pools: readonly AffixPool[];
+    rarities: readonly RarityTier[];
+}
+export interface RolledAffix {
+    id: string;
+    stat: string;
+    op: AffixOp;
+    value: number;
+}
+export interface RolledItem {
+    baseId: string;
+    rarity: string;
+    name: string;
+    affixes: readonly RolledAffix[];
+    stats: Record<string, number>;
+}
+export declare function seededRng(seed: string | number): () => number;
+export interface AffixRoller {
+    rollRarity(rng: () => number): RarityTier;
+    roll(base: ItemBaseDef, rarityId: string, rng: () => number): RolledItem;
+    rollRandom(base: ItemBaseDef, rng: () => number): RolledItem;
+}
+export declare function createAffixRoller(config: RollerConfig): AffixRoller;

package/dist/item/affix.js

@@ -0,0 +1,133 @@
+import { pickWeighted } from "../world/scatterItems.js";
+function hashSeed(seed) {
+    const text = typeof seed === "number" ? seed.toString() : seed;
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function seededRng(seed) {
+    let a = hashSeed(seed) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function resolveRoll(roll, rng) {
+    if (typeof roll === "number")
+        return roll;
+    const [min, max] = roll;
+    return min + rng() * (max - min);
+}
+function resolveCount(count, rng) {
+    if (typeof count === "number")
+        return count;
+    const [min, max] = count;
+    return min + Math.floor(rng() * (max - min + 1));
+}
+function assertConfig(config) {
+    if (config.rarities.length === 0)
+        throw new Error("affix roller must have at least one rarity tier");
+    for (const tier of config.rarities) {
+        if (!(tier.weight > 0))
+            throw new Error(`rarity "${tier.id}" weight must be positive`);
+    }
+}
+export function createAffixRoller(config) {
+    assertConfig(config);
+    const poolById = new Map(config.pools.map((p) => [p.id, p]));
+    const rarityById = new Map(config.rarities.map((r) => [r.id, r]));
+    const rarityEntries = config.rarities.map((value) => ({ value, weight: value.weight }));
+    function candidatesFor(base, rarity) {
+        const allowed = rarity.pools;
+        const out = [];
+        for (const poolId of base.pools) {
+            if (allowed !== undefined && !allowed.includes(poolId))
+                continue;
+            const pool = poolById.get(poolId);
+            if (pool === undefined)
+                continue;
+            for (const affix of pool.affixes)
+                out.push(affix);
+        }
+        return out;
+    }
+    function drawAffixes(candidates, count, rng) {
+        const remaining = candidates.slice();
+        const drawn = [];
+        const target = Math.min(count, remaining.length);
+        for (let i = 0; i < target; i++) {
+            const picked = pickWeighted(remaining.map((value) => ({ value, weight: value.weight })), rng());
+            if (picked === null)
+                break;
+            remaining.splice(remaining.indexOf(picked), 1);
+            drawn.push({ id: picked.id, stat: picked.stat, op: picked.op ?? "add", value: resolveRoll(picked.roll, rng) });
+        }
+        return drawn;
+    }
+    function computeStats(base, rarity, affixes) {
+        const scale = rarity.statScale ?? 1;
+        const stats = {};
+        for (const [key, value] of Object.entries(base.baseStats))
+            stats[key] = value * scale;
+        for (const affix of affixes) {
+            if (affix.op === "add")
+                stats[affix.stat] = (stats[affix.stat] ?? 0) + affix.value;
+        }
+        for (const affix of affixes) {
+            if (affix.op === "mul")
+                stats[affix.stat] = (stats[affix.stat] ?? 0) * affix.value;
+        }
+        return stats;
+    }
+    function composeName(base, rarity, affixes) {
+        const prefix = affixes.find((a) => affixNameFor(a)?.position === "prefix");
+        const suffix = affixes.find((a) => affixNameFor(a)?.position === "suffix");
+        const parts = [];
+        if (rarity.namePart !== undefined)
+            parts.push(rarity.namePart);
+        if (prefix !== undefined)
+            parts.push(affixNameFor(prefix).text);
+        parts.push(base.name);
+        if (suffix !== undefined)
+            parts.push(affixNameFor(suffix).text);
+        return parts.join(" ");
+    }
+    const nameByAffixId = new Map();
+    for (const pool of config.pools) {
+        for (const affix of pool.affixes)
+            if (affix.namePart !== undefined)
+                nameByAffixId.set(affix.id, affix.namePart);
+    }
+    function affixNameFor(affix) {
+        return nameByAffixId.get(affix.id);
+    }
+    return {
+        rollRarity(rng) {
+            const picked = pickWeighted(rarityEntries, rng());
+            return picked ?? config.rarities[config.rarities.length - 1];
+        },
+        roll(base, rarityId, rng) {
+            const rarity = rarityById.get(rarityId);
+            if (rarity === undefined)
+                throw new Error(`unknown rarity tier: ${rarityId}`);
+            const count = resolveCount(rarity.affixCount, rng);
+            const affixes = drawAffixes(candidatesFor(base, rarity), count, rng);
+            return {
+                baseId: base.id,
+                rarity: rarity.id,
+                name: composeName(base, rarity, affixes),
+                affixes,
+                stats: computeStats(base, rarity, affixes),
+            };
+        },
+        rollRandom(base, rng) {
+            return this.roll(base, this.rollRarity(rng).id, rng);
+        },
+    };
+}

package/dist/item/durability.d.ts

@@ -0,0 +1,51 @@
+export interface RepairMaterial {
+    item: string;
+    perPoint: number;
+}
+export interface RepairSpec {
+    materials: readonly RepairMaterial[];
+    station?: string;
+    qualityLossPerRepair?: number;
+}
+export interface DurabilitySpec {
+    max: number;
+    wearPerUse?: number;
+    wearPerHit?: number;
+    disableAtZero?: boolean;
+    repair?: RepairSpec;
+}
+export interface DurabilityState {
+    current: number;
+    max: number;
+}
+export type WearKind = "use" | "hit";
+export interface RepairCost {
+    item: string;
+    count: number;
+}
+export interface RepairQuote {
+    materials: readonly RepairCost[];
+    restored: number;
+    state: DurabilityState;
+}
+export declare function createDurability(spec: DurabilitySpec): DurabilityState;
+export declare function durabilityFraction(state: DurabilityState): number;
+export declare function isBroken(state: DurabilityState): boolean;
+export declare function isDisabled(spec: DurabilitySpec, state: DurabilityState): boolean;
+export declare function wearAmount(spec: DurabilitySpec, kind: WearKind): number;
+export declare function applyWear(state: DurabilityState, amount: number): DurabilityState;
+export declare function wear(spec: DurabilitySpec, state: DurabilityState, kind: WearKind, times?: number): DurabilityState;
+export declare function canRepairAt(spec: DurabilitySpec, stationId?: string): boolean;
+export declare function repairQuote(spec: DurabilitySpec, state: DurabilityState, options?: {
+    to?: number;
+    station?: string;
+}): RepairQuote | null;
+export interface DurabilityTracker {
+    init(instanceId: string, spec: DurabilitySpec): DurabilityState;
+    get(instanceId: string): DurabilityState | null;
+    set(instanceId: string, state: DurabilityState): void;
+    wear(instanceId: string, spec: DurabilitySpec, kind: WearKind, times?: number): DurabilityState | null;
+    isDisabled(instanceId: string, spec: DurabilitySpec): boolean;
+    remove(instanceId: string): void;
+}
+export declare function createDurabilityTracker(): DurabilityTracker;

package/dist/item/durability.js

@@ -0,0 +1,78 @@
+function clamp(value, min, max) {
+    return value < min ? min : value > max ? max : value;
+}
+export function createDurability(spec) {
+    const max = Math.max(0, spec.max);
+    return { current: max, max };
+}
+export function durabilityFraction(state) {
+    return state.max <= 0 ? 0 : clamp(state.current / state.max, 0, 1);
+}
+export function isBroken(state) {
+    return state.current <= 0;
+}
+export function isDisabled(spec, state) {
+    return isBroken(state) && spec.disableAtZero !== false;
+}
+export function wearAmount(spec, kind) {
+    return kind === "use" ? spec.wearPerUse ?? 0 : spec.wearPerHit ?? 0;
+}
+export function applyWear(state, amount) {
+    if (amount <= 0)
+        return state;
+    return { current: clamp(state.current - amount, 0, state.max), max: state.max };
+}
+export function wear(spec, state, kind, times = 1) {
+    return applyWear(state, wearAmount(spec, kind) * Math.max(0, times));
+}
+export function canRepairAt(spec, stationId) {
+    const repair = spec.repair;
+    if (repair === undefined)
+        return false;
+    return repair.station === undefined || repair.station === stationId;
+}
+export function repairQuote(spec, state, options) {
+    const repair = spec.repair;
+    if (repair === undefined)
+        return null;
+    if (repair.station !== undefined && repair.station !== options?.station)
+        return null;
+    const loss = repair.qualityLossPerRepair ?? 0;
+    const newMax = Math.max(1, state.max - loss);
+    const capped = Math.min(state.current, newMax);
+    const target = clamp(options?.to ?? newMax, capped, newMax);
+    const restored = Math.max(0, target - capped);
+    const materials = repair.materials.map((m) => ({ item: m.item, count: Math.ceil(m.perPoint * restored) }));
+    return { materials, restored, state: { current: target, max: newMax } };
+}
+export function createDurabilityTracker() {
+    const states = new Map();
+    return {
+        init(instanceId, spec) {
+            const state = createDurability(spec);
+            states.set(instanceId, state);
+            return state;
+        },
+        get(instanceId) {
+            return states.get(instanceId) ?? null;
+        },
+        set(instanceId, state) {
+            states.set(instanceId, state);
+        },
+        wear(instanceId, spec, kind, times) {
+            const current = states.get(instanceId);
+            if (current === undefined)
+                return null;
+            const next = wear(spec, current, kind, times);
+            states.set(instanceId, next);
+            return next;
+        },
+        isDisabled(instanceId, spec) {
+            const state = states.get(instanceId);
+            return state !== undefined && isDisabled(spec, state);
+        },
+        remove(instanceId) {
+            states.delete(instanceId);
+        },
+    };
+}

package/dist/item/modularItem.d.ts

@@ -0,0 +1,46 @@
+export interface MountSlotDef {
+    id: string;
+    accepts: string | readonly string[];
+    required?: boolean;
+}
+export interface ModularItemDef {
+    id: string;
+    baseStats: Record<string, number>;
+    slots: readonly MountSlotDef[];
+}
+export interface PartDef {
+    id: string;
+    category: string;
+    stats?: Record<string, number>;
+    multipliers?: Record<string, number>;
+}
+export interface InstalledPart {
+    slotId: string;
+    part: PartDef;
+}
+export type InstallResult = {
+    status: "ok";
+    installed: readonly InstalledPart[];
+} | {
+    status: "rejected";
+    reason: "unknown-slot" | "wrong-category" | "slot-occupied";
+};
+export declare function slotById(def: ModularItemDef, slotId: string): MountSlotDef | null;
+export declare function slotAccepts(slot: MountSlotDef, category: string): boolean;
+export declare function install(def: ModularItemDef, installed: readonly InstalledPart[], slotId: string, part: PartDef): InstallResult;
+export declare function uninstall(installed: readonly InstalledPart[], slotId: string): readonly InstalledPart[];
+export declare function partInSlot(installed: readonly InstalledPart[], slotId: string): PartDef | null;
+export declare function computeEffectiveStats(def: ModularItemDef, installed: readonly InstalledPart[]): Record<string, number>;
+export declare function missingRequiredSlots(def: ModularItemDef, installed: readonly InstalledPart[]): string[];
+export declare function isComplete(def: ModularItemDef, installed: readonly InstalledPart[]): boolean;
+export interface ModularItem {
+    readonly def: ModularItemDef;
+    parts(): readonly InstalledPart[];
+    install(slotId: string, part: PartDef): InstallResult;
+    uninstall(slotId: string): readonly InstalledPart[];
+    partInSlot(slotId: string): PartDef | null;
+    effectiveStats(): Record<string, number>;
+    missingRequired(): string[];
+    isComplete(): boolean;
+}
+export declare function createModularItem(def: ModularItemDef, initial?: readonly InstalledPart[]): ModularItem;

package/dist/item/modularItem.js

@@ -0,0 +1,75 @@
+export function slotById(def, slotId) {
+    return def.slots.find((s) => s.id === slotId) ?? null;
+}
+export function slotAccepts(slot, category) {
+    return typeof slot.accepts === "string" ? slot.accepts === category : slot.accepts.includes(category);
+}
+export function install(def, installed, slotId, part) {
+    const slot = slotById(def, slotId);
+    if (slot === null)
+        return { status: "rejected", reason: "unknown-slot" };
+    if (!slotAccepts(slot, part.category))
+        return { status: "rejected", reason: "wrong-category" };
+    if (installed.some((i) => i.slotId === slotId))
+        return { status: "rejected", reason: "slot-occupied" };
+    return { status: "ok", installed: [...installed, { slotId, part }] };
+}
+export function uninstall(installed, slotId) {
+    return installed.filter((i) => i.slotId !== slotId);
+}
+export function partInSlot(installed, slotId) {
+    return installed.find((i) => i.slotId === slotId)?.part ?? null;
+}
+export function computeEffectiveStats(def, installed) {
+    const stats = { ...def.baseStats };
+    for (const { part } of installed) {
+        if (part.stats === undefined)
+            continue;
+        for (const [key, value] of Object.entries(part.stats))
+            stats[key] = (stats[key] ?? 0) + value;
+    }
+    for (const { part } of installed) {
+        if (part.multipliers === undefined)
+            continue;
+        for (const [key, factor] of Object.entries(part.multipliers))
+            stats[key] = (stats[key] ?? 0) * factor;
+    }
+    return stats;
+}
+export function missingRequiredSlots(def, installed) {
+    return def.slots.filter((s) => s.required === true && !installed.some((i) => i.slotId === s.id)).map((s) => s.id);
+}
+export function isComplete(def, installed) {
+    return missingRequiredSlots(def, installed).length === 0;
+}
+export function createModularItem(def, initial = []) {
+    let installed = initial;
+    return {
+        def,
+        parts() {
+            return installed;
+        },
+        install(slotId, part) {
+            const result = install(def, installed, slotId, part);
+            if (result.status === "ok")
+                installed = result.installed;
+            return result;
+        },
+        uninstall(slotId) {
+            installed = uninstall(installed, slotId);
+            return installed;
+        },
+        partInSlot(slotId) {
+            return partInSlot(installed, slotId);
+        },
+        effectiveStats() {
+            return computeEffectiveStats(def, installed);
+        },
+        missingRequired() {
+            return missingRequiredSlots(def, installed);
+        },
+        isComplete() {
+            return isComplete(def, installed);
+        },
+    };
+}

package/dist/meta/changelog.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.5.0";
+export declare const VERSION = "0.7.0";
 export interface ChangelogEntry {
     migrate: readonly string[];
     added: readonly string[];

package/dist/meta/changelog.js

@@ -1,5 +1,57 @@
-export const VERSION = "0.5.0";
+export const VERSION = "0.7.0";
 export const CHANGELOG = {
+    "0.7.0": {
+        migrate: [
+            "Bump every @jgengine/* dependency to ^0.7.0 (the eight packages version in lockstep).",
+            "0.7.0 is additive — every 0.6.0 API is unchanged, so no code change is required to upgrade; existing games keep the orbit/first-person camera, single-player-entity control, and every existing primitive exactly as before.",
+            "Opt into any new system by importing it directly: a camera rig via camera.rig; a sensor/* probe with @jgengine/shell/vision renderers; an ai/* director over the nav/ navmesh; turn/* + tactics/* for turn-based games; cards/* + board/* for deckbuilders; crafting/* for recipes/production/farming; survival/* + world/{envField,weather,realm} for survival; combat/{abilityKit,animationState,defensiveWindow} for action feel; physics/{vehicleBody,traversal,structure,ragdoll} for vehicles/destruction; session/* for contested/round/downed/ring/extraction machines; and multiplayer/* for lag-comp/hidden-commit/matchmaking.",
+            "entityStore.update() now also accepts name, so possession/form can retarget an instance's catalog id without despawn/respawn.",
+        ],
+        added: [
+            "Navigation & pointer input — nav/navGrid (A* walkable grid), nav/pathFollow, input/pointer (PointerHit), scene/selection, interaction/contextMenu, and PlayableGame.pointer (worldHit, marquee select, right-click verbs, move/aim commands) in @jgengine/shell.",
+            "Camera rig library — eight rigs on PlayableGame.camera (topDown/iso, rts, shoulder, lockOn, chase + cockpit/hood/rear, orbit, first), a cinematic keyframe path, rig cross-fade, followEntityId: null, and a shared camera-shake/trauma channel (cameraShake / useCameraShake).",
+            "Physics constraints & actors — PhysicsWorld joints (hinge/fixed/distance/spring), onCollision gameplay-event hook, physics/ragdoll, physics/carryable, physics/forceVolume + platformCarry, and physics/spatialGrid broad-phase.",
+            "Vehicles, mounts & racing — physics/vehicleBody (suspension + grip curve), input/axisInput, physics/buoyancy boat, scene/mount multi-seat rideable, physics/damageZones crash stages, and game/race (raceTrack + raceState).",
+            "Traversal & destruction — physics/traversal (grapple/glide), world/carve (voxel carve/deposit + terrain write-back), and physics/structure (integrity graph → debris collapse).",
+            "AI director/behavior/crowds — ai/spawnDirector, ai/threat, ai/jobBoard, ai/crowd flow field, and a scene/behaviors patrol descriptor over the navmesh.",
+            "Abilities, resources & cooldowns — combat/abilityKit (four-state slots), stats/accumulatorMeter + stats/eventMeter (ult/streak), scene/autoTarget, combat/resistance matrix, game/runDraft, and @jgengine/react useAbilitySlots / useEventMeter.",
+            "Character combat feel — combat/animationState, combat/attackTags, combat/defensiveWindow, combat/comboString, combat/breakMeters (stagger/buildup), movement/dash, combat/hitReaction (hitstop + shake), combat/telegraph, and typed float-text styling.",
+            "Item & gear — item/durability, item/affix roller, item/modularItem, and inventory/storageTier (carried vs banked + delivery/insurance/consolation).",
+            "Objective/mode/session machines — session/contestedChannel, session/roundState, combat/downed, session/ring, session/extraction, and runtime/persistenceScope (run-vs-meta split with HostPersistence.resetScenario).",
+            "Turn-based & tactics — turn/turnLoop (+ action-economy pools), turn/commit (immediate/simultaneous/rewind), tactics/tacticalGrid, tactics/predictiveQuery, tactics/snapshot, tactics/surface, and shared combat/effects resolveAreaTargets.",
+            "Card & board stack — cards/cardPile, cards/modifierPipeline, board/laneBoard, board/timelineBoard, inventory/shapedGrid, and @jgengine/react dragLayer.",
+            "Crafting, tech & production — crafting/recipe graph, economy/techTree (prereq-gated unlocks), crafting/production buildings + conveyor/power, and crafting/crop farming state machine.",
+            "Survival & environment — survival/decayMeter, survival/moodle, survival/regionHealth, world/envField, world/weather (+ coarse fire grid), world/realm composition, and @jgengine/shell FireSpreadLayer.",
+            "World items & loot — game/worldItem (third scene bucket), game/lootFilter, onDeath.dropMode world scatter, PlayableGame.worldItem render binding, and @jgengine/react useWorldItems / useNearestWorldItem.",
+            "Placement, building & terraform — world/placementController, world/connectors, world/support, world/walls, world/placedStructureStore, world/terraform (editable terrain write-back), world/buildPermissions, and @jgengine/shell ghost/tint/brush renderers.",
+            "Map, HUD & ping — world/markers, world/fog, world/minimap, game/ping, @jgengine/react Minimap/Compass/WorldMap + useMarkers/useFog, and @jgengine/shell bakeTerrainMap + MapMarkerBeacons.",
+            "Audio & voice — audio/audioFalloff contract, time/beatClock, @jgengine/shell positional emitters (PlayableGame.audio + entitySounds/objectSounds), and @jgengine/ws voiceChannel router.",
+            "Interaction verbs & minigames — interaction/skillCheck, interaction/qte, scene/captureCheck + scene/roster, stats/rollCheck, dialogue skill-check gates, and @jgengine/react SkillCheckBar/QteTrack/CaptureOdds + useRoster.",
+            "Sensors, vision & observer — sensor/revealQuery, sensor/hiddenStateProbe, sensor/frustumSensor, sensor/recordingBuffer, the observer camera rig, and @jgengine/shell vision/replay renderers.",
+            "Player embodiment & expression — scene/possession, scene/form (shapeshift), game/cosmetics loadouts, and social emote broadcast over the presence layer.",
+            "Multiplayer depth — multiplayer/lagCompensation (position history + rewind), multiplayer/simultaneousCommit, multiplayer/combatSnapshot replay, scene/stationClaim shared-vehicle facets, economy/sharedWallet, and multiplayer/matchmaking (browse/filter/join-by-code) with @jgengine/node host support.",
+        ],
+        changed: [],
+        removed: [],
+    },
+    "0.6.0": {
+        migrate: [
+            "Bump every @jgengine/* dependency to ^0.6.0 (the eight packages version in lockstep).",
+            "0.6.0 is additive — every 0.5.0 API is unchanged, so no code change is required to upgrade.",
+            "Optional: mount an outdoor scene by handing environment({ terrain, weather, vegetation, water, structures }) from @jgengine/core/world/features to the shell — @jgengine/shell EnvironmentScene renders terrain, rain/snow, grass, ocean, and buildings from it, while gameplay reads the same world through the renderer-free query primitives (resolveTerrainField, windField, waterSurface, scatter, buildingIndex).",
+        ],
+        added: [
+            "@jgengine/core/world query primitives — renderer-free world sampling so gameplay reads the same world the shell renders: world/terrain (TerrainField, noiseField, resolveTerrainField, resolveGroundStep), world/wind (windField), world/water (waterSurface, waterSurfaceFromDescriptor, CPU Gerstner), world/scatter (scatter — seeded overlap-aware point distribution), world/buildings (generateBuilding, generateBuildingDistrict) and world/buildingIndex (buildingIndex — at/within/nearest/isInside/blockers).",
+            "@jgengine/core/world/features gained composable outdoor descriptors: environment(), terrain(), rain(), snow(), grass(), ocean(), building().",
+            "@jgengine/core/world/regions (createRegionField — blend content-agnostic biomes by nearest selector, extends TerrainField so it ground-snaps) and world/scatterItems (scatterItems — region-driven, grounded, above-water/slope-aware content scatter with pickWeighted).",
+            "@jgengine/core/physics/physicsWorld — standalone fixed-capacity rigid-body sim (SoA buffers, spatial-hash broadphase, sleeping) for many colliding dynamic bodies; independent of the defineGame physics character-controller config.",
+            "ctx.time simulation clock (@jgengine/core/time/simClock) — dt in onTick is game time, so decay/regen/AI written as rate*dt obey pause and fast-forward for free. Configure via defineGame({ time: { scale?, speeds?, dayLength?, start?, startPaused? } }); pause/play/setSpeed/calendar controls, and useGameClock() in React.",
+            "@jgengine/shell environment/terrain/water/weather/structures renderers — EnvironmentScene mounts an environment() descriptor; GrassField, ProceduralGround, Ocean, RainField, SnowField, LightningStrike, GeneratedBuilding, and world/InstancedBodies (renders PhysicsWorld bodies).",
+            "@jgengine/react/liveBind — useFrameBind drives a DOM/SVG element from a per-frame value without re-rendering React.",
+        ],
+        changed: [],
+        removed: [],
+    },
     "0.5.0": {
         migrate: [
             "Bump every @jgengine/* dependency to ^0.5.0 (the eight packages version in lockstep).",

package/dist/movement/dash.d.ts

@@ -0,0 +1,37 @@
+export interface DashConfig {
+    distance: number;
+    durationMs: number;
+    iframes: {
+        fromMs: number;
+        toMs: number;
+    };
+    staminaCost: number;
+    staminaMax: number;
+    staminaRegenPerSecond: number;
+    cooldownMs: number;
+}
+export interface DashDirection {
+    x: number;
+    z: number;
+}
+export type DashRejection = {
+    reason: "no-stamina" | "cooldown" | "dashing";
+};
+export interface DashBurst {
+    direction: DashDirection;
+    durationMs: number;
+    distance: number;
+}
+export declare function iframeActive(config: DashConfig, elapsedMs: number): boolean;
+export declare function dashEase(t: number): number;
+export declare function dashOffset(config: DashConfig, dir: DashDirection, elapsedMs: number): [number, number, number];
+export interface DashState {
+    tryDash(direction: DashDirection, nowMs: number): DashRejection | DashBurst;
+    tick(dtSeconds: number, nowMs: number): void;
+    stamina(): number;
+    staminaFraction(): number;
+    isDashing(nowMs: number): boolean;
+    isInvulnerable(nowMs: number): boolean;
+    offset(nowMs: number): [number, number, number];
+}
+export declare function createDashState(config: DashConfig): DashState;

package/dist/movement/dash.js

@@ -0,0 +1,65 @@
+export function iframeActive(config, elapsedMs) {
+    return elapsedMs >= config.iframes.fromMs && elapsedMs < config.iframes.toMs;
+}
+export function dashEase(t) {
+    const clamped = Math.max(0, Math.min(1, t));
+    return 1 - (1 - clamped) * (1 - clamped);
+}
+export function dashOffset(config, dir, elapsedMs) {
+    const traveled = dashEase(elapsedMs / config.durationMs) * config.distance;
+    const len = Math.hypot(dir.x, dir.z);
+    if (len === 0)
+        return [0, 0, 0];
+    return [(dir.x / len) * traveled, 0, (dir.z / len) * traveled];
+}
+export function createDashState(config) {
+    let stamina = config.staminaMax;
+    let dashStartMs = null;
+    let dashDir = { x: 0, z: 0 };
+    let cooldownUntil = 0;
+    function elapsed(nowMs) {
+        if (dashStartMs === null)
+            return null;
+        const dt = nowMs - dashStartMs;
+        return dt >= 0 && dt < config.durationMs ? dt : null;
+    }
+    return {
+        tryDash(direction, nowMs) {
+            if (elapsed(nowMs) !== null)
+                return { reason: "dashing" };
+            if (nowMs < cooldownUntil)
+                return { reason: "cooldown" };
+            if (stamina < config.staminaCost)
+                return { reason: "no-stamina" };
+            stamina -= config.staminaCost;
+            dashStartMs = nowMs;
+            dashDir = direction;
+            cooldownUntil = nowMs + config.cooldownMs;
+            return { direction, durationMs: config.durationMs, distance: config.distance };
+        },
+        tick(dtSeconds, nowMs) {
+            if (dashStartMs !== null && nowMs - dashStartMs >= config.durationMs)
+                dashStartMs = null;
+            stamina = Math.min(config.staminaMax, stamina + config.staminaRegenPerSecond * dtSeconds);
+        },
+        stamina() {
+            return stamina;
+        },
+        staminaFraction() {
+            return config.staminaMax <= 0 ? 0 : stamina / config.staminaMax;
+        },
+        isDashing(nowMs) {
+            return elapsed(nowMs) !== null;
+        },
+        isInvulnerable(nowMs) {
+            const dt = elapsed(nowMs);
+            return dt !== null && iframeActive(config, dt);
+        },
+        offset(nowMs) {
+            const dt = elapsed(nowMs);
+            if (dt === null)
+                return [0, 0, 0];
+            return dashOffset(config, dashDir, dt);
+        },
+    };
+}

package/dist/multiplayer/combatSnapshot.d.ts

@@ -0,0 +1,45 @@
+export interface SnapshotUnit {
+    id: string;
+    stats: Readonly<Record<string, number>>;
+}
+export interface BoardSnapshot {
+    ownerId: string;
+    units: readonly SnapshotUnit[];
+    stats: Readonly<Record<string, number>>;
+    seed: number;
+    capturedAt: number;
+}
+export interface SerializeBoardArgs {
+    ownerId: string;
+    units: readonly SnapshotUnit[];
+    stats?: Readonly<Record<string, number>>;
+    seed?: number;
+    capturedAt?: number;
+}
+export declare function serializeBoard(args: SerializeBoardArgs): BoardSnapshot;
+export declare function cloneSnapshot(snapshot: BoardSnapshot): BoardSnapshot;
+export interface CombatRules {
+    attackStat: string;
+    healthStat: string;
+    maxRounds?: number;
+    critChance?: number;
+    critMultiplier?: number;
+}
+export type CombatSide = "a" | "b" | "draw";
+export interface ReplayBlow {
+    round: number;
+    attacker: CombatSide;
+    attackerUnit: string;
+    defenderUnit: string;
+    damage: number;
+    crit: boolean;
+    defenderHealthAfter: number;
+}
+export interface ReplayResult {
+    winner: CombatSide;
+    rounds: number;
+    blows: readonly ReplayBlow[];
+    survivorsA: readonly string[];
+    survivorsB: readonly string[];
+}
+export declare function replayCombat(a: BoardSnapshot, b: BoardSnapshot, rules: CombatRules): ReplayResult;