@jgengine/core 0.11.0 → 0.13.0

package/dist/gameplay.d.ts

@@ -5,14 +5,16 @@ export { runPipeline } from "./cards/modifierPipeline.js";
 export { type CropDef, type CropTileState } from "./crafting/crop.js";
 export { advanceTransport, createProductionState, drainOutput, feedProduction, productionBuilding, resolvePowerGrid, tickProduction, } from "./crafting/production.js";
 export { canCraft, craft, craftSeconds, createRecipeGraph, stationSatisfied, type RecipeDef, type RecipeItem, } from "./crafting/recipe.js";
+export { createAuctionBook, type Auction, type AuctionSettlement } from "./economy/auctionBook.js";
 export { createListingBook, type Listing } from "./economy/listingBook.js";
+export { createPriceHistory, type PriceStats, type SaleRecord } from "./economy/priceHistory.js";
 export { addScheduledRule, advanceLedger, annotate, balanceOf, cancelRule, capAmount, createResourceLedger, curveScale, pauseRule, redirect, rejectWhen, resumeRule, taxFraction, thresholdScale, type AdvanceOptions, type AdvanceResult, type AppliedTransaction, type CatchUpPolicy, type LedgerEvent, type LedgerEventKind, type PolicyContext, type PolicyRead, type Precision, type ResourceLedger, type ResourcePolicy, type ResourceTransaction, type RuleCursor, type ScheduledRule, type ThresholdBand, } from "./economy/resourceLedger.js";
 export { type TechNodeDef } from "./economy/techTree.js";
 export { balance, charge, chargeAll, createEmptyWallet, grant, isOverdrawn } from "./economy/wallet.js";
 export { DEFAULT_CHAT_BODY_LENGTH, DEFAULT_CHAT_HISTORY_LIMIT, DEFAULT_CHAT_RATE_LIMIT, createChatRateLimiter, type Chat, type ChatMessage, type ChatRateLimit, type ChatSendResult, } from "./game/chat.js";
 export { playControlsActive } from "./game/controlGate.js";
 export { createCosmetics } from "./game/cosmetics.js";
-export { defineGame, type GameDefinition, type GameDefinitionConfig, type GameLoop, type InventoryDeclaration, type LifecycleConfig, type PhysicsConfig, } from "./game/defineGame.js";
+export { type GameDefinition, type GameDefinitionConfig, type GameLoop, type InventoryDeclaration, type LifecycleConfig, type PhysicsConfig, } from "./game/defineGame.js";
 export { defineSystem, type SystemDefinition, type SystemEventHandlers, type SystemTick } from "./game/defineSystem.js";
 export { createGameDialogue, dialogueSlot } from "./game/dialogue.js";
 export { createGameEvents, type CombatTelegraphEvent, type CombatVfxEvent, type EntityDiedEvent, type EntityFloatTextEvent, type GameEventMap, type GameEvents, type RetainedVfxKind, type StatLevelUpEvent, type VfxKind, type VfxRef, } from "./game/events.js";

package/dist/gameplay.js

@@ -5,14 +5,16 @@ export { runPipeline } from "./cards/modifierPipeline.js";
 export {} from "./crafting/crop.js";
 export { advanceTransport, createProductionState, drainOutput, feedProduction, productionBuilding, resolvePowerGrid, tickProduction, } from "./crafting/production.js";
 export { canCraft, craft, craftSeconds, createRecipeGraph, stationSatisfied, } from "./crafting/recipe.js";
+export { createAuctionBook } from "./economy/auctionBook.js";
 export { createListingBook } from "./economy/listingBook.js";
+export { createPriceHistory } from "./economy/priceHistory.js";
 export { addScheduledRule, advanceLedger, annotate, balanceOf, cancelRule, capAmount, createResourceLedger, curveScale, pauseRule, redirect, rejectWhen, resumeRule, taxFraction, thresholdScale, } from "./economy/resourceLedger.js";
 export {} from "./economy/techTree.js";
 export { balance, charge, chargeAll, createEmptyWallet, grant, isOverdrawn } from "./economy/wallet.js";
 export { DEFAULT_CHAT_BODY_LENGTH, DEFAULT_CHAT_HISTORY_LIMIT, DEFAULT_CHAT_RATE_LIMIT, createChatRateLimiter, } from "./game/chat.js";
 export { playControlsActive } from "./game/controlGate.js";
 export { createCosmetics } from "./game/cosmetics.js";
-export { defineGame, } from "./game/defineGame.js";
+export {} from "./game/defineGame.js";
 export { defineSystem } from "./game/defineSystem.js";
 export { createGameDialogue, dialogueSlot } from "./game/dialogue.js";
 export { createGameEvents, } from "./game/events.js";

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/inventory/inventoryModel.d.ts

@@ -35,25 +35,41 @@ export type MoveResult = {
     status: "rejected";
     reason: "invalid-slot" | "empty-slot" | "wrong-kind" | "no-space";
 };
+/** Outcome of {@link splitStack}: the new state, or a rejection reason. */
+export type SplitResult = {
+    status: "ok";
+    state: InventoryState;
+} | {
+    status: "rejected";
+    reason: "invalid-slot" | "empty-slot" | "invalid-amount" | "no-space" | "slot-occupied";
+};
 /**
  * A bag of stackable items supporting add, remove, count, and move — the base inventory model.
  *
  * @capability inventory-grid a bag of stackable items with add, remove, and move
-  * @internal
-  */
+ */
 export declare function createEmptyInventory(layout: InventoryLayout): InventoryState;
-/** @internal */
+/** Add `count` of `itemId` — into a specific `options.slot`, or auto-stacked across free/partial slots. Rejects on no space or wrong kind. */
 export declare function putItem(state: InventoryState, layout: InventoryLayout, traits: ItemTraits, itemId: string, count: number, options?: {
     slot?: number;
 }): PutResult;
-/** @internal */
+/** Remove `count` of `itemId`, draining from the last matching stacks first. Rejects if fewer than `count` are held. */
 export declare function takeItem(state: InventoryState, itemId: string, count: number): TakeResult;
-/** @internal */
+/** Total quantity of `itemId` summed across every stack in the inventory. */
 export declare function countItem(state: InventoryState, itemId: string): number;
-/** @internal */
+/** True when the inventory holds at least `count` of `itemId`. */
 export declare function hasItem(state: InventoryState, itemId: string, count: number): boolean;
-/** @internal */
+/** Move the stack at `fromSlot` to `toSlot` (or auto-stack when omitted) — swapping, merging with remainder, or relocating across two inventories. Rejects on empty source, wrong kind, or no space. */
 export declare function moveItem(from: InventoryState, fromSlot: number, to: InventoryState, toLayout: InventoryLayout, traits: ItemTraits, toSlot?: number): MoveResult;
+/**
+ * Splits `amount` off the stack in `slot` into `toSlot` (or the first empty slot when `toSlot` is
+ * omitted). Limit-agnostic: it does not consult {@link ItemTraits}, so a same-item target merges by
+ * simple addition. Rejects an empty source, `amount <= 0`, `amount >= stack count` (a split must
+ * leave both sides non-empty), no free slot, or a target holding a different item.
+ *
+ * @capability inventory-split split a stack into a target or first-empty slot
+ */
+export declare function splitStack(state: InventoryState, slot: number, amount: number, toSlot?: number): SplitResult;
 export interface InventorySet<TId extends string> {
     put(id: TId, itemId: string, count: number, options?: {
         slot?: number;
@@ -65,5 +81,5 @@ export interface InventorySet<TId extends string> {
     state(id: TId): InventoryState;
     replaceState(id: TId, state: InventoryState): void;
 }
-/** @internal */
+/** Build a keyed set of named inventories from their `layouts`, sharing one `traits` table — the stateful façade over put/take/move/count. */
 export declare function createInventorySet<TId extends string>(layouts: Record<TId, InventoryLayout>, traits: ItemTraits): InventorySet<TId>;

package/dist/inventory/inventoryModel.js

@@ -2,8 +2,7 @@
  * A bag of stackable items supporting add, remove, count, and move — the base inventory model.
  *
  * @capability inventory-grid a bag of stackable items with add, remove, and move
-  * @internal
-  */
+ */
 export function createEmptyInventory(layout) {
     return { slots: new Array(layout.slots).fill(null) };
 }
@@ -82,13 +81,13 @@ function explicitPut(state, layout, traits, itemId, count, slot) {
     slots[slot] = { itemId, count: newCount };
     return { status: "ok", state: { slots } };
 }
-/** @internal */
+/** Add `count` of `itemId` — into a specific `options.slot`, or auto-stacked across free/partial slots. Rejects on no space or wrong kind. */
 export function putItem(state, layout, traits, itemId, count, options) {
     if (options?.slot !== undefined)
         return explicitPut(state, layout, traits, itemId, count, options.slot);
     return autoPut(state, layout, traits, itemId, count);
 }
-/** @internal */
+/** Remove `count` of `itemId`, draining from the last matching stacks first. Rejects if fewer than `count` are held. */
 export function takeItem(state, itemId, count) {
     if (count <= 0)
         return { status: "ok", state };
@@ -107,7 +106,7 @@ export function takeItem(state, itemId, count) {
     }
     return { status: "ok", state: { slots } };
 }
-/** @internal */
+/** Total quantity of `itemId` summed across every stack in the inventory. */
 export function countItem(state, itemId) {
     let total = 0;
     for (const slot of state.slots)
@@ -115,11 +114,11 @@ export function countItem(state, itemId) {
             total += slot.count;
     return total;
 }
-/** @internal */
+/** True when the inventory holds at least `count` of `itemId`. */
 export function hasItem(state, itemId, count) {
     return countItem(state, itemId) >= count;
 }
-/** @internal */
+/** Move the stack at `fromSlot` to `toSlot` (or auto-stack when omitted) — swapping, merging with remainder, or relocating across two inventories. Rejects on empty source, wrong kind, or no space. */
 export function moveItem(from, fromSlot, to, toLayout, traits, toSlot) {
     if (fromSlot < 0 || fromSlot >= from.slots.length)
         return { status: "rejected", reason: "invalid-slot" };
@@ -171,7 +170,47 @@ export function moveItem(from, fromSlot, to, toLayout, traits, toSlot) {
         to: sameInventory ? { slots: fromSlots } : { slots: toSlots },
     };
 }
-/** @internal */
+/**
+ * Splits `amount` off the stack in `slot` into `toSlot` (or the first empty slot when `toSlot` is
+ * omitted). Limit-agnostic: it does not consult {@link ItemTraits}, so a same-item target merges by
+ * simple addition. Rejects an empty source, `amount <= 0`, `amount >= stack count` (a split must
+ * leave both sides non-empty), no free slot, or a target holding a different item.
+ *
+ * @capability inventory-split split a stack into a target or first-empty slot
+ */
+export function splitStack(state, slot, amount, toSlot) {
+    if (slot < 0 || slot >= state.slots.length)
+        return { status: "rejected", reason: "invalid-slot" };
+    const source = state.slots[slot];
+    if (source === null)
+        return { status: "rejected", reason: "empty-slot" };
+    if (amount <= 0 || amount >= source.count)
+        return { status: "rejected", reason: "invalid-amount" };
+    let target = toSlot;
+    if (target === undefined) {
+        target = state.slots.findIndex((s) => s === null);
+        if (target === -1)
+            return { status: "rejected", reason: "no-space" };
+    }
+    else {
+        if (target < 0 || target >= state.slots.length)
+            return { status: "rejected", reason: "invalid-slot" };
+        if (target === slot)
+            return { status: "rejected", reason: "slot-occupied" };
+        const dest = state.slots[target];
+        if (dest !== null && dest.itemId !== source.itemId)
+            return { status: "rejected", reason: "slot-occupied" };
+    }
+    const slots = state.slots.slice();
+    const dest = slots[target];
+    slots[slot] = { itemId: source.itemId, count: source.count - amount };
+    slots[target] =
+        dest === null || dest === undefined
+            ? { itemId: source.itemId, count: amount }
+            : { itemId: source.itemId, count: dest.count + amount };
+    return { status: "ok", state: { slots } };
+}
+/** Build a keyed set of named inventories from their `layouts`, sharing one `traits` table — the stateful façade over put/take/move/count. */
 export function createInventorySet(layouts, traits) {
     const states = new Map();
     for (const id of Object.keys(layouts)) {

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.13.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,54 @@
 /** Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating. */
-export const VERSION = "0.11.0";
+export const VERSION = "0.13.0";
 /** Per-version engine changelog keyed by semver string (e.g. `"0.10.0"`). */
 export const CHANGELOG = {
+    "0.13.0": {
+        migrate: [
+            "Bump lockstep SDK packages to ^0.13.0: @jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}. CLI jgengine is 0.10.0; @jgengine/github is unchanged.",
+            "Nothing required — additive release. Two overridable defaults changed in the player's favor: offline games persist to localStorage automatically (#1207) and rigged catalog assets animate by default via clip metadata + semantic clip roles (#1209); opt out explicitly if a game relied on the old behavior.",
+        ],
+        added: [
+            "Drop-in inventory grid, window manager, and character sheet (#1220) — @jgengine/react InventoryGrid (drag/stack/split), toggleable windows backed by @jgengine/core/ui/panelModel, CharacterSheet paperdoll; all HudTheme-skinnable.",
+            "Serializable runtime snapshots (#1179) — capture/restore live runtime state including magazine state (@jgengine/core/combat/magazine) and stat modifiers.",
+            "Portable weapon plumbing (#1211) — @jgengine/core/combat/weaponFire composes trigger → magazine → spread → projectile/hitscan as data.",
+            "Portable leveling (#1206) and portable damage-pool access (#1208) as genre-agnostic game-context seams.",
+            "Named combat VFX presets (#1204) — @jgengine/core/combat/vfxPresets; a visible attack is one line.",
+            "Runtime-measured render-bounds hitboxes (#1227) — colliders wrap what the shell actually mounts.",
+            "Procedural part motion for rig-less part-composed characters (#1222); squash & stretch and death splat (#1229).",
+            "City fabric (#1191) — streetGenerator + cityGenerator, editor bake verb, street-aware lots, road junctions, grounding.",
+            "jgengine recipe CLI (#1214, #1231) — vetted wired compositions, compile-pinned against the SDK.",
+            "Editor/debug modes mirrored to the URL with an editor exit (#1203); dependency-free WebGL screenshot script in the game template (#1202).",
+        ],
+        changed: [
+            "Offline games persist to localStorage by default (#1207); rigged assets animate by default (#1209).",
+            "RTS camera pan inversion fixed (#1228); sprite raycast warning silenced and duplicate nameplate health bars removed (#1194); scaffolded F2+E editor Tailwind @source renders its theme (#1195).",
+            "Outside-game DX: stat-pool no-op stability, camera-transparent decor, cleaner install/version output, headless UI-intent seam (#1223).",
+        ],
+        removed: [],
+    },
+    "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],
+    };
+}