@jgengine/core 0.11.0 → 0.12.0

package/dist/inventory/encumbrance.d.ts

@@ -0,0 +1,69 @@
+/** One carried stack: an item id and how many of it the carrier holds. */
+export interface LoadEntry {
+    itemId: string;
+    quantity: number;
+}
+/** Resolves the per-unit mass of an item id. Injected so mass tables stay decoupled from this module. */
+export type MassResolver = (itemId: string) => number;
+/**
+ * Tuning for where the encumbrance bands sit and how hard the carrier is slowed.
+ * Both fields are load *fractions* / multipliers in `0..1`, never absolute mass.
+ */
+export interface EncumbranceConfig {
+    /**
+     * Load fraction at/above which the carrier becomes encumbered (loses sprint & jump and
+     * starts slowing). Below it the carrier is unencumbered. Default `0.85`.
+     */
+    soft?: number;
+    /**
+     * Move-speed multiplier reached as load approaches full capacity (fraction → 1), the floor
+     * the progressive slow curve bottoms out at just before immobility. Default `0.5`.
+     */
+    floor?: number;
+}
+/** Coarse carry state: free-moving, slowed, or pinned in place. */
+export type EncumbranceTier = "unencumbered" | "encumbered" | "immobile";
+/** Serializable snapshot of a carrier's load versus capacity and the movement consequences. */
+export interface EncumbranceState {
+    /** Total carried mass (never negative). */
+    mass: number;
+    /** Carrying capacity this load was measured against. */
+    capacity: number;
+    /** `mass / capacity`, clamped to be finite and non-negative; may exceed 1 when overloaded. */
+    fraction: number;
+    tier: EncumbranceTier;
+    /** Movement speed scalar in `0..1`: 1 when unencumbered, decays toward `floor`, 0 when immobile. */
+    moveMultiplier: number;
+    canSprint: boolean;
+    canJump: boolean;
+    immobile: boolean;
+}
+/**
+ * Sum the mass of every carried stack using an injected per-unit mass resolver. Bounded by the
+ * number of entries; allocates nothing. Missing or negative unit masses are treated as 0.
+ *
+ * @param entries carried stacks (`{ itemId, quantity }`, compatible with any inventory listing).
+ * @param massOf per-unit mass lookup for an item id.
+ * @capability carry-load sum carried mass from item stacks via an injected mass resolver
+ */
+export declare function totalLoad(entries: readonly LoadEntry[], massOf: MassResolver): number;
+/**
+ * Progressive move-speed multiplier for a raw load fraction: 1 while at/below `soft`, a linear
+ * decay from 1 down toward `floor` across the `soft..1` band, and 0 once at/over capacity.
+ * Pure and side-effect free — the curve `resolveEncumbrance` reads for `moveMultiplier`.
+ *
+ * @capability encumbrance-move-curve progressive move-speed multiplier from a carry-load fraction
+ */
+export declare function encumbranceMoveMultiplier(fraction: number, config?: EncumbranceConfig): number;
+/**
+ * Resolve carried mass against carrying capacity into a serializable encumbrance state: load
+ * fraction, tier, and the movement consequences (`canSprint`/`canJump`/`immobile` gates plus a
+ * progressive `moveMultiplier`). Below `soft` the carrier is unencumbered and unhindered; from
+ * `soft` up to capacity it is encumbered — no sprint or jump, and speed decays from 1 toward
+ * `floor`; at or above capacity it is immobile (multiplier 0). Deterministic and allocation-light;
+ * pair with {@link totalLoad} to derive `mass` from an inventory and a mass table. A capacity of 0
+ * or less pins any positive load as immobile (`fraction` 1) so the state stays finite/serializable.
+ *
+ * @capability carry-encumbrance carried mass vs capacity into movement penalty tiers and a speed multiplier
+ */
+export declare function resolveEncumbrance(mass: number, capacity: number, config?: EncumbranceConfig): EncumbranceState;

package/dist/inventory/encumbrance.js

@@ -0,0 +1,68 @@
+const DEFAULT_SOFT = 0.85;
+const DEFAULT_FLOOR = 0.5;
+/**
+ * Sum the mass of every carried stack using an injected per-unit mass resolver. Bounded by the
+ * number of entries; allocates nothing. Missing or negative unit masses are treated as 0.
+ *
+ * @param entries carried stacks (`{ itemId, quantity }`, compatible with any inventory listing).
+ * @param massOf per-unit mass lookup for an item id.
+ * @capability carry-load sum carried mass from item stacks via an injected mass resolver
+ */
+export function totalLoad(entries, massOf) {
+    let total = 0;
+    for (const entry of entries) {
+        if (entry.quantity <= 0)
+            continue;
+        const unit = massOf(entry.itemId);
+        if (unit > 0)
+            total += unit * entry.quantity;
+    }
+    return total;
+}
+/**
+ * Progressive move-speed multiplier for a raw load fraction: 1 while at/below `soft`, a linear
+ * decay from 1 down toward `floor` across the `soft..1` band, and 0 once at/over capacity.
+ * Pure and side-effect free — the curve `resolveEncumbrance` reads for `moveMultiplier`.
+ *
+ * @capability encumbrance-move-curve progressive move-speed multiplier from a carry-load fraction
+ */
+export function encumbranceMoveMultiplier(fraction, config) {
+    const soft = config?.soft ?? DEFAULT_SOFT;
+    const floor = config?.floor ?? DEFAULT_FLOOR;
+    if (fraction >= 1)
+        return 0;
+    if (fraction <= soft)
+        return 1;
+    const span = 1 - soft;
+    const t = span > 0 ? (fraction - soft) / span : 1;
+    return 1 - (1 - floor) * t;
+}
+/**
+ * Resolve carried mass against carrying capacity into a serializable encumbrance state: load
+ * fraction, tier, and the movement consequences (`canSprint`/`canJump`/`immobile` gates plus a
+ * progressive `moveMultiplier`). Below `soft` the carrier is unencumbered and unhindered; from
+ * `soft` up to capacity it is encumbered — no sprint or jump, and speed decays from 1 toward
+ * `floor`; at or above capacity it is immobile (multiplier 0). Deterministic and allocation-light;
+ * pair with {@link totalLoad} to derive `mass` from an inventory and a mass table. A capacity of 0
+ * or less pins any positive load as immobile (`fraction` 1) so the state stays finite/serializable.
+ *
+ * @capability carry-encumbrance carried mass vs capacity into movement penalty tiers and a speed multiplier
+ */
+export function resolveEncumbrance(mass, capacity, config) {
+    const soft = config?.soft ?? DEFAULT_SOFT;
+    const safeMass = mass > 0 ? mass : 0;
+    const fraction = capacity > 0 ? safeMass / capacity : safeMass > 0 ? 1 : 0;
+    const immobile = fraction >= 1;
+    const tier = immobile ? "immobile" : fraction >= soft ? "encumbered" : "unencumbered";
+    const unencumbered = tier === "unencumbered";
+    return {
+        mass: safeMass,
+        capacity,
+        fraction,
+        tier,
+        moveMultiplier: encumbranceMoveMultiplier(fraction, config),
+        canSprint: unencumbered,
+        canJump: unencumbered,
+        immobile,
+    };
+}

package/dist/item/durability.js

@@ -1,6 +1,4 @@
-function clamp(value, min, max) {
-    return value < min ? min : value > max ? max : value;
-}
+import { clamp } from "../math/scalar.js";
 export function createDurability(spec) {
     const max = Math.max(0, spec.max);
     return { current: max, max };

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.11.0";
+export declare const VERSION = "0.12.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,7 +1,30 @@
 /** Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating. */
-export const VERSION = "0.11.0";
+export const VERSION = "0.12.0";
 /** Per-version engine changelog keyed by semver string (e.g. `"0.10.0"`). */
 export const CHANGELOG = {
+    "0.12.0": {
+        migrate: [
+            "Bump lockstep SDK packages to ^0.12.0: @jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}. CLI jgengine is 0.9.0; @jgengine/github is unchanged.",
+            "Author games through defineGame from @jgengine/shell — the single public authoring entry. Core's constructor was renamed defineGame → defineGameDefinition (@jgengine/core/game/defineGame); only hosts and tooling call it. GamePlayer/GamePlayerShell are @internal; GameHost is the documented mount and owns the editor summon (?mode=editor, F2+E, dev save endpoint) — delete per-game editor bootstraps.",
+            "Declare worlds with world({ id, ground: { mode, size, surface? }, physics? }) from @jgengine/core/world/place (flat/round/voxel/board). environment() still works as the legacy consumption path for editor-written scene data — nothing required for existing games; author dressing in the editor.",
+        ],
+        added: [
+            "world() place API (#1178) — @jgengine/core/world/place: ground mode/size discriminated at type and runtime (flat {x,z} with Infinity, round {radius}, voxel generator domain, board {x,y} cells); ground.surface matter/feel laws; per-place physics over the game default; multiple worlds per game; shell PlaceScene substrate rendering; seeds via seedForPlace.",
+            "@jgengine/shell/gameKit — happy-path authoring surface: authoring, mount, stores, systems, authored-scene helpers, HUD primitives, seeded rng.",
+            "Portable generic stat pools — @jgengine/core/stats/statPool (bounded named pools: health, energy, heat, ammo…); entity stats rebuilt on them; recipe in skill jgengine-combat.",
+            "Auction-house economy primitives (#1086) — @jgengine/core/economy/auctionBook: timed bid auctions, escrowed bids, outbid refunds, optional buyout, anti-snipe extension, settlement with house cut; plus market price history.",
+            "Portable minimap marker sources — core world seam for game minimaps; recipe in skill jgengine-ui.",
+            "Unified seed-driven path network + city generation v2 (#1103, #1106) — street/block/building dials, zone bands, presets, junction geometry, road-derived parcels; shell renders real intersections, curbs, lane lines, tunnels, bridge decks.",
+            "Mesh-accurate hitboxes (#1075), auto-fit colliders from model bounds (#1072), movement obstruction from fitted boxes + compound-box openings (#1077).",
+            "Editor overhaul (#1110) — materials/lighting/scripting/animation/multiplayer workspaces, command palette, minimap bake (#1036), GLB thumbnails, hierarchy DnD/keys/context/visibility-lock, multi-select inspector, console RPC, asset drag-place, ortho projection, pivot modes, play chrome.",
+            "Editor authoring pipeline — entity definitions and starter catalogs (#1012), Data-tab catalogs/schema fields (#1043), promote authored scene folder to runnable game (#1011), shared trigger primitive with goal/win rules (#1013), asset import rewrites game/assets.ts (#1042).",
+        ],
+        changed: [
+            "npx jgengine create scaffolds a thin infinite flat world() place (no more 96m meadow); editor blankWorld drops pre-baked seeded grass — dressing belongs in editor.scene.json.",
+            "Environment studio visual-quality pass; grass fields no longer rebuild geometry per frame (#1090).",
+        ],
+        removed: [],
+    },
     "0.11.0": {
         migrate: [
             "Bump lockstep SDK packages to ^0.11.0: @jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}. CLI jgengine and @jgengine/github may lag on their own version lines.",

package/dist/movement/movementModel.d.ts

@@ -121,9 +121,23 @@ export declare function advancePlayerMotion(motion: PlayerMotionState, intent: M
 /** A placed scene object the walking player collides against as a circle-vs-AABB obstacle. */
 export interface CollisionObstacle {
     position: readonly [number, number, number];
-    /** Box half-size on each axis. Default `[0.5, 0.5, 0.5]` (unit-box scene objects). */
+    /** Box half-size on each axis. Default `[0.5, 0.5, 0.5]` (unit-box scene objects). Ignored when `boxes` is set. */
     halfExtents?: readonly [number, number, number];
+    /** Local center shift added to `position` for the single-AABB path (the collider's yaw-rotated offset). Ignored when `boxes` is set. */
+    offset?: readonly [number, number, number];
+    /**
+     * Optional compound solid: axis-aligned sub-boxes as `min`/`max` **relative to `position`** (add
+     * `position` for world space), already yaw-rotated and conservatively expanded by the caller. When
+     * present the capsule slides against EACH sub-box instead of the single `halfExtents` AABB, so a
+     * concave opening (the gap between an archway's pillars/lintel) lets the capsule pass through.
+     */
+    boxes?: readonly {
+        min: readonly [number, number, number];
+        max: readonly [number, number, number];
+    }[];
 }
+/** @internal Player radius the walking obstruction inflates obstacles by; callers gather within reach of it. */
+export declare const DEFAULT_OBSTACLE_PLAYER_RADIUS = 0.3;
 /**
  * Resolve a horizontal step against nearby placed objects with classic
  * axis-separated sliding (try X, then Z against the post-X position) so

package/dist/movement/movementModel.js

@@ -187,7 +187,8 @@ export function advancePlayerMotion(motion, intent, forwardX, forwardZ, baseSpee
     };
 }
 const DEFAULT_OBSTACLE_HALF_EXTENTS = [0.5, 0.5, 0.5];
-const DEFAULT_OBSTACLE_PLAYER_RADIUS = 0.3;
+/** @internal Player radius the walking obstruction inflates obstacles by; callers gather within reach of it. */
+export const DEFAULT_OBSTACLE_PLAYER_RADIUS = 0.3;
 /** Feet-to-head span used for the obstacle's vertical overlap test; matches DEFAULT_VOXEL_DIMS.height. */
 const OBSTACLE_PLAYER_HEIGHT = 1.8;
 function clampAxisStep(originalCoord, step, min, max) {
@@ -216,22 +217,39 @@ export function resolveObstacleStep(current, stepX, stepZ, obstacles, playerRadi
     const reachX = Math.abs(stepX) + playerRadius;
     const reachZ = Math.abs(stepZ) + playerRadius;
     const nearby = [];
-    for (const obstacle of obstacles) {
-        const halfExtents = obstacle.halfExtents ?? DEFAULT_OBSTACLE_HALF_EXTENTS;
-        const obstacleBottom = obstacle.position[1] - halfExtents[1];
-        const obstacleTop = obstacle.position[1] + halfExtents[1];
-        if (obstacleTop <= feetY || obstacleBottom >= headY)
-            continue;
-        const dx = obstacle.position[0] - current[0];
-        const dz = obstacle.position[2] - current[2];
-        if (Math.abs(dx) > halfExtents[0] + reachX || Math.abs(dz) > halfExtents[2] + reachZ)
-            continue;
+    const considerBox = (minX, maxX, minY, maxY, minZ, maxZ) => {
+        // Vertical-span cull: a sub-box entirely above the head (walk under the lintel) or below the feet is skipped.
+        if (maxY <= feetY || minY >= headY)
+            return;
+        const centerX = (minX + maxX) / 2;
+        const centerZ = (minZ + maxZ) / 2;
+        const halfX = (maxX - minX) / 2;
+        const halfZ = (maxZ - minZ) / 2;
+        if (Math.abs(centerX - current[0]) > halfX + reachX || Math.abs(centerZ - current[2]) > halfZ + reachZ)
+            return;
         nearby.push({
-            minX: obstacle.position[0] - halfExtents[0] - playerRadius,
-            maxX: obstacle.position[0] + halfExtents[0] + playerRadius,
-            minZ: obstacle.position[2] - halfExtents[2] - playerRadius,
-            maxZ: obstacle.position[2] + halfExtents[2] + playerRadius,
+            minX: minX - playerRadius,
+            maxX: maxX + playerRadius,
+            minZ: minZ - playerRadius,
+            maxZ: maxZ + playerRadius,
         });
+    };
+    for (const obstacle of obstacles) {
+        const px = obstacle.position[0];
+        const py = obstacle.position[1];
+        const pz = obstacle.position[2];
+        if (obstacle.boxes !== undefined && obstacle.boxes.length > 0) {
+            for (const box of obstacle.boxes) {
+                considerBox(px + box.min[0], px + box.max[0], py + box.min[1], py + box.max[1], pz + box.min[2], pz + box.max[2]);
+            }
+            continue;
+        }
+        const halfExtents = obstacle.halfExtents ?? DEFAULT_OBSTACLE_HALF_EXTENTS;
+        const offset = obstacle.offset;
+        const cx = px + (offset !== undefined ? offset[0] : 0);
+        const cy = py + (offset !== undefined ? offset[1] : 0);
+        const cz = pz + (offset !== undefined ? offset[2] : 0);
+        considerBox(cx - halfExtents[0], cx + halfExtents[0], cy - halfExtents[1], cy + halfExtents[1], cz - halfExtents[2], cz + halfExtents[2]);
     }
     let resultX = stepX;
     for (const box of nearby) {

package/dist/movement/playerMovement.js

@@ -1,6 +1,7 @@
 import { applyHorizontalImpulses, applyMotionImpulses } from "../runtime/motionIntents.js";
 import { groundFieldFor, hasEnvironmentTerrain, sampleSlope } from "../world/terrain.js";
-import { advancePlayerMotion, constrainStepToAxis, createEmptyMovementKeys, createPlayerMotionState, nearbyObstacles, resolveMovementIntent, resolveObstacleStep, snapPositionToGrid, } from "./movementModel.js";
+import { resolveColliders } from "../scene/colliders.js";
+import { advancePlayerMotion, constrainStepToAxis, createEmptyMovementKeys, createPlayerMotionState, DEFAULT_OBSTACLE_PLAYER_RADIUS, resolveMovementIntent, resolveObstacleStep, snapPositionToGrid, } from "./movementModel.js";
 import { approachYaw, steerYaw } from "./steering.js";
 import { advanceVoxelPlayer, createVoxelPlayerBody, } from "./voxelController.js";
 const DEFAULT_TURN_SPEED = 2.4;
@@ -180,7 +181,7 @@ export function stepPlayerMovement(ctx, userId, input, dt, tuning, heading) {
         stepZ = constrained.stepZ;
     }
     if (tuning.movement?.collideObjects === true) {
-        const obstacles = nearbyObstacles(ctx.scene.object.list(), player.position);
+        const obstacles = gatherMovementObstacles(ctx, player.position, stepX, stepZ);
         const resolved = resolveObstacleStep(player.position, stepX, stepZ, obstacles);
         stepX = resolved.stepX;
         stepZ = resolved.stepZ;
@@ -234,3 +235,102 @@ export function stepPlayerMovement(ctx, userId, input, dt, tuning, heading) {
         dt,
     });
 }
+/** Feet-to-head span the obstruction test uses; matches `movementModel`'s `OBSTACLE_PLAYER_HEIGHT`. */
+const OBSTACLE_PLAYER_HEIGHT = 1.8;
+/**
+ * Largest collider half-extent the bounded broadphase assumes, so an object whose blocking box reaches
+ * the player still has its center inside the `inBox` query — a ~4m wall (half-extent ~2m) is caught. An
+ * object wider than this on an axis could be missed at its far edge; raise it if a wider blocker exists.
+ */
+const OBSTACLE_MAX_HALF_EXTENT = 4;
+/**
+ * Gather the player's nearby blocking obstacles from resolved colliders — the mesh-accurate replacement
+ * for the old `nearbyObstacles(list(), …)` which emitted a default 1×1×1 box per object. Bounded by an
+ * `inBox` broadphase (reach ≥ player radius + max half-extent so wide walls can't be missed), then, per
+ * candidate, keeps only blocking physical colliders and emits their real half-extents/offset (or, for a
+ * mesh collider carrying `boxes`, the compound sub-boxes), conservatively yaw-rotated by the object's
+ * `rotationY`. Objects with no resolved collider fall back to the default box; objects whose colliders
+ * don't block stop obstructing. Runs for both the shell's local player and a host, so parity is automatic.
+ */
+function gatherMovementObstacles(ctx, position, stepX, stepZ) {
+    const reachX = Math.abs(stepX) + DEFAULT_OBSTACLE_PLAYER_RADIUS + OBSTACLE_MAX_HALF_EXTENT;
+    const reachZ = Math.abs(stepZ) + DEFAULT_OBSTACLE_PLAYER_RADIUS + OBSTACLE_MAX_HALF_EXTENT;
+    const min = [
+        position[0] - reachX,
+        position[1] - OBSTACLE_MAX_HALF_EXTENT,
+        position[2] - reachZ,
+    ];
+    const max = [
+        position[0] + reachX,
+        position[1] + OBSTACLE_PLAYER_HEIGHT + OBSTACLE_MAX_HALF_EXTENT,
+        position[2] + reachZ,
+    ];
+    const obstacles = [];
+    for (const object of ctx.scene.object.inBox(min, max)) {
+        const set = ctx.scene.object.collidersOf(object.instanceId);
+        if (set === null) {
+            // No resolved collider: preserve today's default 1×1×1 box.
+            obstacles.push({ position: object.position });
+            continue;
+        }
+        for (const collider of resolveColliders(set)) {
+            if (!collider.blocks || collider.purpose !== "physical")
+                continue;
+            obstacles.push(obstacleFromCollider(collider, object.position, object.rotationY));
+        }
+    }
+    return obstacles;
+}
+/** One blocking collider as a {@link CollisionObstacle}: a compound `boxes` obstacle for a mesh collider
+ * carrying sub-boxes, else a single half-extents/offset AABB. Yaw is applied by conservatively expanding
+ * each AABB to its rotated extent (mirroring `worldOffset`), so the obstruction never under-covers. */
+function obstacleFromCollider(collider, position, rotationY) {
+    const cos = Math.cos(rotationY);
+    const sin = Math.sin(rotationY);
+    const shape = collider.shape;
+    if (shape.kind === "mesh" && shape.boxes !== undefined && shape.boxes.length > 0) {
+        return {
+            position,
+            boxes: shape.boxes.map((b) => yawExpandLocalBox(b.min, b.max, cos, sin)),
+        };
+    }
+    let hx;
+    let hy;
+    let hz;
+    if (shape.kind === "sphere") {
+        hx = hy = hz = shape.radius;
+    }
+    else {
+        hx = shape.halfExtents[0];
+        hy = shape.halfExtents[1];
+        hz = shape.halfExtents[2];
+    }
+    const offset = shape.offset;
+    const ox = offset !== undefined ? offset[0] : 0;
+    const oy = offset !== undefined ? offset[1] : 0;
+    const oz = offset !== undefined ? offset[2] : 0;
+    return {
+        position,
+        // Rotate the offset by yaw (mirror of colliders.worldOffset), expand the extents to the rotated AABB.
+        offset: [ox * cos + oz * sin, oy, -ox * sin + oz * cos],
+        halfExtents: [Math.abs(hx * cos) + Math.abs(hz * sin), hy, Math.abs(hx * sin) + Math.abs(hz * cos)],
+    };
+}
+/** Yaw-rotate an entity-local AABB about the object origin and re-fit it to an axis-aligned box, expressed
+ * as `min`/`max` relative to `position`. Conservative: the rotated box is grown to its enclosing AABB. */
+function yawExpandLocalBox(boxMin, boxMax, cos, sin) {
+    const centerX = (boxMin[0] + boxMax[0]) / 2;
+    const centerY = (boxMin[1] + boxMax[1]) / 2;
+    const centerZ = (boxMin[2] + boxMax[2]) / 2;
+    const halfX = (boxMax[0] - boxMin[0]) / 2;
+    const halfY = (boxMax[1] - boxMin[1]) / 2;
+    const halfZ = (boxMax[2] - boxMin[2]) / 2;
+    const rcX = centerX * cos + centerZ * sin;
+    const rcZ = -centerX * sin + centerZ * cos;
+    const rhX = Math.abs(halfX * cos) + Math.abs(halfZ * sin);
+    const rhZ = Math.abs(halfX * sin) + Math.abs(halfZ * cos);
+    return {
+        min: [rcX - rhX, centerY - halfY, rcZ - rhZ],
+        max: [rcX + rhX, centerY + halfY, rcZ + rhZ],
+    };
+}

package/dist/multiplayer/combatSnapshot.js

@@ -1,3 +1,4 @@
+import { randomSeedFrom, stepRandomSeed } from "../random/rng.js";
 function cloneStats(stats) {
     return { ...stats };
 }
@@ -21,14 +22,18 @@ export function cloneSnapshot(snapshot) {
         capturedAt: snapshot.capturedAt,
     });
 }
-function mulberry32(seed) {
-    let a = seed >>> 0;
+/**
+ * Deterministic per-replay PRNG built from the shared {@link randomSeedFrom} /
+ * {@link stepRandomSeed} primitives. `randomSeedFrom` takes the raw integer seed
+ * without string hashing, so the emitted sequence is byte-identical to the former
+ * inline mulberry32 — replay determinism across peers is preserved.
+ */
+function seededPrng(seed) {
+    let cursor = randomSeedFrom(seed);
     return () => {
-        a |= 0;
-        a = (a + 0x6d2b79f5) | 0;
-        let t = Math.imul(a ^ (a >>> 15), 1 | a);
-        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+        const [value, next] = stepRandomSeed(cursor);
+        cursor = next;
+        return value;
     };
 }
 function toLive(snapshot, rules) {
@@ -43,7 +48,7 @@ export function replayCombat(a, b, rules) {
     const maxRounds = rules.maxRounds ?? 100;
     const critChance = rules.critChance ?? 0;
     const critMultiplier = rules.critMultiplier ?? 2;
-    const prng = mulberry32((a.seed ^ (b.seed * 0x9e3779b1)) >>> 0);
+    const prng = seededPrng((a.seed ^ (b.seed * 0x9e3779b1)) >>> 0);
     const liveA = toLive(a, rules);
     const liveB = toLive(b, rules);
     const blows = [];

package/dist/multiplayer/presenceModel.d.ts

@@ -32,6 +32,8 @@ export interface PoseSyncRules {
     /** Unchanged poses refresh the keep-alive stamp at most this often. */
     keepAliveRefreshMs: number;
 }
+/** Canonical client-authoritative pose-sync tuning shared by every host transport (WS, Convex). */
+export declare const DEFAULT_POSE_SYNC_RULES: PoseSyncRules;
 export interface PoseSyncDecision {
     position: {
         x: number;

package/dist/multiplayer/presenceModel.js

@@ -1,3 +1,11 @@
+/** Canonical client-authoritative pose-sync tuning shared by every host transport (WS, Convex). */
+export const DEFAULT_POSE_SYNC_RULES = {
+    maxSpeed: 12,
+    maxVerticalOffset: 3,
+    minElapsedSec: 0.05,
+    maxElapsedSec: 0.5,
+    keepAliveRefreshMs: 10_000,
+};
 function appearanceEqual(a, b) {
     if (a === b)
         return true;

package/dist/physics/drivableVehicle.d.ts

@@ -12,6 +12,8 @@ export interface DrivableVehicleOptions {
 export interface DrivableVehiclePose {
     position: DrivableVehiclePosition;
     rotationY: number;
+    rotationX: number;
+    rotationZ: number;
     dt: number;
 }
 /** {@link tickDrivableVehicle}'s result — the ready-to-apply pose patch plus the raw sim step for HUD/telemetry reads. */

package/dist/physics/drivableVehicle.js

@@ -10,7 +10,7 @@ export function tickDrivableVehicle(vehicle, dt, axis, options = {}) {
     const [x, y, z] = step.position;
     const resolvedY = options.groundHeight === undefined ? y : options.groundHeight(x, z);
     return {
-        pose: { position: [x, resolvedY, z], rotationY: step.heading, dt },
+        pose: { position: [x, resolvedY, z], rotationX: step.bodyPitch, rotationY: step.heading, rotationZ: step.bodyRoll, dt },
         step,
     };
 }

package/dist/physics/flightDynamics.d.ts

@@ -0,0 +1,82 @@
+import { type GravityField } from "./gravityField.js";
+/** Three-dimensional world-space vector used by the flight model. */
+export type FlightVector = readonly [number, number, number];
+/** Supported aerodynamic/propulsion families. */
+export type AircraftKind = "fixedWing" | "rotorcraft" | "vtol";
+/** Normalized pilot inputs for one flight-simulation tick. */
+export interface FlightControlInput {
+    throttle: number;
+    pitch: number;
+    roll: number;
+    yaw: number;
+    collective?: number;
+    airbrake?: number;
+    afterburner?: number;
+    vectoring?: number;
+}
+/** Angular authority, response, damping, and self-leveling configuration. */
+export interface FlightControlRates {
+    pitch: number;
+    roll: number;
+    yaw: number;
+    response: number;
+    damping: number;
+    stability: number;
+}
+/** Data-first physical tuning shared by all aircraft instances of one catalog type. */
+export interface AircraftTuning {
+    kind: AircraftKind;
+    mass: number;
+    gravity?: number;
+    maxThrust: number;
+    maxSpeed: number;
+    drag: number;
+    sideDrag: number;
+    lift: number;
+    stallSpeed: number;
+    controls: FlightControlRates;
+    afterburnerMultiplier?: number;
+    hoverThrust?: number;
+    rotorResponse?: number;
+    groundEffectHeight?: number;
+    vtolTransitionSpeed?: number;
+    groundClearance?: number;
+}
+/** Spawn state and injectable world-field samplers for an aircraft instance. */
+export interface AircraftOptions {
+    position?: FlightVector;
+    velocity?: FlightVector;
+    rotation?: FlightVector;
+    wind?: (position: FlightVector) => FlightVector;
+    groundHeight?: (x: number, z: number) => number;
+    gravityField?: GravityField;
+}
+/** Pose and aerodynamic telemetry returned after one flight tick. */
+export interface AircraftStep {
+    position: FlightVector;
+    velocity: FlightVector;
+    rotation: FlightVector;
+    forwardSpeed: number;
+    airspeed: number;
+    verticalSpeed: number;
+    angleOfAttack: number;
+    liftFraction: number;
+    stalled: boolean;
+    grounded: boolean;
+    gForce: number;
+}
+/** Stateful six-degree-of-freedom aircraft simulation. */
+export interface AircraftDynamics {
+    tick(dt: number, input: FlightControlInput): AircraftStep;
+    pose(): {
+        position: FlightVector;
+        rotation: FlightVector;
+    };
+    velocity(): FlightVector;
+    resetTo(position: FlightVector, rotation?: FlightVector): void;
+    setVelocity(velocity: FlightVector): void;
+}
+/** Six-degree-of-freedom arcade flight model for fixed-wing, helicopter, and VTOL aircraft.
+ * @capability flight-dynamics simulate fixed-wing, helicopter, and VTOL aircraft
+ */
+export declare function createAircraftDynamics(tuning: AircraftTuning, options?: AircraftOptions): AircraftDynamics;