@jgengine/core 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -34,6 +34,68 @@ At publish, rename this heading to the new version and mirror the entries into
 
 ### Fixed
 
+## 0.17.0
+
+### Migrate
+
+- **Bump lockstep SDK packages to `^0.17.0`:** `@jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}`. CLI `jgengine` is `0.14.0`; `@jgengine/github` is `0.4.0`.
+- **A deleted player profile stays deleted.** When a game persists players (`save.scope` includes `player`), hydrating a member with no `jgPlayerProfiles` row no longer falls back to the copy of their state kept on the server row — that copy was resurrected and then written back as authoritative, so a world reset that cleared profiles but not servers silently restored every player's old balance. A game whose save scope excludes players (`"none"`, `"chunks"`) is unchanged: the server-row copy is still their state. If you seed members onto a server row without going through `joinServer`, write their profile row too.
+- **`slotsPerServer` is capped at 256** (`JG_MAX_MEMBERS_PER_SERVER`). `createGameServerFunctions` now throws at wiring time on a larger value instead of accepting it and failing at the write that overflows the document. One server is one Convex document holding the world row, the roster, and every member's session state; a bigger number was never a bigger world. Shard across servers, or move world state into `jgWorldChunks`.
+- **The tick cron only sweeps games that declare `loop.onTick`.** A game with no tick hook used to pay a full hydrate plus a full persist every second per running server, for a snapshot `runtime.tick` returned unchanged; it now costs nothing while idle. If you relied on the tick cron to autosave a hookless game, the 60s `flushDirtyServers` cron and the `flushSave` mutation still do it.
+
+### Changed
+
+- **Walking NPCs now stop at the geometry that stops the player.** `wander`, `patrol`, and `ctx.scene.entity.moveToward` consulted no obstacles at all, so a pedestrian walked through the building the player cannot enter. All three now slide their step against the scene's blocking physical colliders — the same query `stepPlayerMovement` reads. A patrol's path state still advances on its own clock (an authored route is not rewound by contact), but the entity can no longer end a tick inside a solid. Pass `avoidSolids: false` to `moveToward` for a mover meant to ignore the world (a flier, a camera rig).
+- **`@jgengine/assets` verify fails a model source that contributes no index entries.** A model pack that has never been pulled is a pin nothing has ever checked — that is how a Street Pack archive sat in the catalogue titled "Downtown City MegaKit". Record why a pack is not pulled in the new `AssetSource.unpulled` string; materials and sprites pull on demand and are exempt.
+- **`persistServerSnapshot` returns `boolean` and skips a write that would change nothing.** Every subscriber of a query that read a server row re-receives the whole result when that document changes, so an unconditional write on the 1 Hz tick re-pushed the entire world to every client once a second whether or not anything moved. `ServerPersistPlan` gains `changed` (`serverState` / `sessionPlayers` / `revision` / `any`) for hosts that write field-by-field.
+- **`sessionPlayers` is merged over the stored map, not rebuilt from the snapshot**, and entries for non-members are pruned. This is what makes a partially hydrated snapshot safe to persist.
+- **`tickActiveServers` is bounded** to `maxServersPerTick` (default 32) servers per transaction, oldest tick anchor first, instead of pulling every running server of every game into one transaction. `flushDirtyServers` is bounded the same way.
+
+### Added
+
+- **`solidObstaclesNear` / `resolveWalkerStep` (`@jgengine/core/movement/solidObstacles`)** — the engine's single answer to "what is solid here", now shared rather than re-derived per consumer. `solidObstaclesNear(ctx, position, reachX, reachZ)` returns the blocking physical colliders near a point through a bounded `inBox` broadphase; `resolveWalkerStep(ctx, position, stepX, stepZ)` slides a horizontal step against them with the player's axis-separated sliding. Reach for these instead of deriving obstacles from a game catalog's own solidity flags.
+- **Bounded hydration and a client chunk read** — `loadServerSnapshot(ctx, server, runtime, { players, chunkKeys })` hydrates only the members and chunks a mutation will touch instead of a document read per member plus one per chunk, and the generated `getChunks` query lets a client read chunk state by key (capped at `MAX_CHUNKS_PER_QUERY`). Chunks were the documented escape hatch for world state too large for one row, but reads were unbounded and clients could not see them at all, so moving geometry there made things worse. `getServerMeta` returns lobby state (status, member count, revision) without the world payload.
+- **`@jgengine/core/runtime/worldChunks`** — `chunkKeyAt` / `chunkCoordAt` / `chunkKeyOf` / `parseChunkKey` / `chunkKeysInRadius` at a declared cell size, plus `setChunk` / `updateChunk` / `deleteChunk`, which mark the key dirty so the host actually persists it. `chunkKey` was an opaque game-chosen string and the engine never wrote `dirty.chunks`, so every game reimplemented the coordinate mapping and a game that forgot to push a key silently never saved that chunk.
+- **Placed objects cull to `replication.aoiRadius`.** `objects` is the one large spatial replicated set and had no projector, so a world with a few thousand placements sent all of them to every viewer. It now joins the same area-of-interest policy as `entities` and `stats`. Unset `aoiRadius` still replicates everything.
+- **`createGameServerFunctions({ matchmaking: "singleton" })`** — one shared world per game: auto-match always targets the existing world and a join past capacity fails loudly, instead of quietly creating a second world the player would be alone in. `joinServer` also reconciles a stored `slotsPerServer`/`save` that has drifted from the host options, which previously made raising the option a no-op on worlds that already existed. `selectJoinTarget` (`@jgengine/core/runtime/hostPolicy`) is the pure decision behind it.
+- **`GameRuntime.hasTick`** reports whether a runtime declares `loop.onTick`, so any host's scheduler can skip a server whose tick is a no-op by construction.
+
+### Removed
+
+- **Asset source `quaternius-downtown-city`.** It was titled "Downtown City MegaKit" but pinned at the Street Pack archive, which ships Blends/FBX/OBJ only — a pull found no models. Nothing referenced it.
+
+## 0.16.0
+
+### Migrate
+
+- **Bump lockstep SDK packages to `^0.16.0`:** `@jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}`. CLI `jgengine` is `0.13.0`; `@jgengine/github` is `0.3.0`.
+- **Placed objects now replicate.** `objects` joined the always-on baseline snapshot modules, so `ctx.hydrate` replaces the client's placed object set with the host's, the way `entities` already did. A game whose peers all run the same authored placement is unaffected; a game that places props on the client only, after hydrate, must move that placement to the host or keep it out of `ctx.scene.object`.
+
+### Changed
+
+- **`GeneratedBuilding`'s `kit` prop is now the `BuildingKit`**; the per-part React escape hatch it used to name moved to `partRenderer`, so `kit` means the same thing on `GeneratedBuilding` and `InstancedBuildings`. Rename the prop if you passed a `BuildingKitRenderer`.
+
+### Added
+
+- **`modelLoadFallbacks()` from `@jgengine/shell/render/modelLoad`** lists every model the shared loader diagnosed as broken and replaced with a magenta placeholder. A placeholder was only ever a console warning, so a shipped game could render one in its starting area and nobody found out until someone looked at a screenshot; a capture host or smoke test can now require the list to be empty. `clearModelLoadFallbacks()` resets it between runs.
+- **`worldHealthBars.occlude` / `WorldHealthBars`+`WorldNameplates` `occlude` prop.** World bars and nameplates are a screen-space overlay drawn outside the WebGL depth buffer, so nothing in the scene can hide them and an enemy's health bar reads straight through the building it stands behind. Set `occlude: true` to drop a bar when world geometry blocks the line from the player to the entity. Default `false` preserves the always-visible behaviour every shipped game currently relies on.
+
+- **`DustField` + `WeatherLayer` mode `"dust"` (`@jgengine/shell/weather`) — wind-borne particulate.** `WeatherLayer` could only do `clear`/`rain`/`snow`/`mixed`, so an arid, volcanic, ashen, or blown-out world had no way to put anything in the air. Dust drifts on horizontal wind with a slow vertical bob rather than falling; `groundBias` packs density toward the surface, motes fade near the top of the volume so recycled ones do not pop against the sky, and faster motes ride higher. Set `dustAlways` to keep it in the air alongside rain or snow instead of replacing them. Defaults `DEFAULT_DUST_COUNT`/`DEFAULT_DUST_DENSITY` sit beside the rain and snow pair.
+
+- **Authored `city` volumes render their near-LOD facades with a `BuildingKit`.** `CityRules.buildingKit` names a kit; a game registers the bound art with `registerBuildingKit(kit)` from `@jgengine/shell/structures/buildingKitRegistry` and the scene document carries only the name, so a city stays portable and free of model paths. Unset or unknown names keep the palette blocks. This puts the whole `city` primitive — not just the `building()` feature — on the kit path.
+- **`BuildingKit` from `@jgengine/core/world/buildingKit`** binds a generated building's facade part slots to real models, so procedural buildings render as an instanced asset kit instead of untextured blocks. `defineBuildingKit({ parts: { wall: ["Wall_A.glb", …] } })` maps a part kind — or a `${facade}.${kind}` slot — to ordered variants that `kit.variant` indexes, with `fit`/`offset`/`rotation`/`scale`/`tint`/`autoOrient` per variant. Kinds a kit leaves unbound keep rendering the palette block, so a partial kit is a valid kit, and `omit` drops a kind entirely. Pass one through `building({ kit })` or straight to `InstancedBuildings`; `buildingKitVariantCounts(kit)` feeds `generateBuilding` so its seeded picks span exactly the models the kit binds.
+- **`generateBuilding`, `generateBuildingDistrict`, and `createBuildingConfig` are now documented public API** (`@jgengine/core/world/buildings`) and appear in `capabilities.md` under `building-generator`.
+- **`capture.views` on `defineGame`** — named framings (`GameCaptureView`: `look`, `lookFrom`, `spawn`, `state`, `run`, `settleMs`) that `shoot <game> --view <name>` and `drive --view <name>` replay exactly, so a before/after pair is the same view by construction. `shoot <game> --list-views` prints what a game declares; an unknown name fails listing them, and any explicit capture flag still wins over the view's value.
+- **`modelLoadIdleMs()` from `@jgengine/shell/render/modelLoad`** reports how long the shared GLB loader has been idle (`0` while a model is in flight). Capture hosts wait on it instead of guessing a settle delay, so an establishing shot no longer races streaming models.
+- **Per-instance state on placed objects** — `SceneObject.state` (opaque `Record`), set through `ctx.scene.object.setState`/`patchState`/`place({ state })`. It survives move/rotate/setVisual, replicates and saves with the object, and round-trips as `RuntimeObjectRow.flags` via `toRuntimeObjectRow`/`fromRuntimeObjectRow` (`@jgengine/core/multiplayer`). A chest's locked flag or a machine's fill level no longer needs a game-owned map keyed by `instanceId`.
+- **`slotInventory` is a working feature** — `ctx.scene.object.slots` gives objects whose catalog entry declares it real per-instance container contents: `layout`/`state`/`count`, `put`/`take`, and `transferIn`/`transferOut` between a player inventory and the object, all validated against the declared slot count, `accepts` kind filter, and stack limits, with neither side mutated on a rejection. Contents live on `SceneObject.slots`, so they replicate and save with the placement.
+- **`loadServerSnapshot` and `persistServerSnapshot` are public** (`@jgengine/convex/server`), and `createGameServerFunctions` also returns `helpers` (`loadSnapshot`, `applyCommand`, `persistSnapshot`, `runCommand`) bound to the same runtimes and auth mode. A host mutation can now pair snapshot work with its own table writes in one transaction; the registered `runCommand` mutation delegates to `helpers.runCommand`, so there is one implementation.
+
+### Fixed
+
+- **Open storefronts are no longer holes through the building.** `generateBuilding` emitted an open ground-floor store as a lone `storefront` panel with no wall behind it, while every upper-floor window was correctly backed by one. Storefront and window materials render at 0.56 opacity and a generated building is a hollow shell, so those bays let you see straight through the building to the world beyond — and open stores only land on the street-facing facade, so a row of shops along a road was the worst case. The bay now emits its wall first, exactly as an upper floor does.
+- **`joinServer`, `flushSave`, `flushDirtyServers`, and the `auto` autosave can write player profiles again.** All four cleared the snapshot's dirty set before handing it to the persist plan, which gates profile writes on exactly that set — so the functions named "flush" flushed the server row and chunks only, and an `onNewPlayer` grant (starting money, starting items) never reached `jgPlayerProfiles`. `joinServer` now persists the snapshot it just marked; the flush paths mark every player dirty first, since hydrating from storage resets the dirty set. `planServerPersist` also clears `dirtyAt` once everything outstanding is written, so a successful flush stops autosave from re-firing forever, and a profile patch no longer clobbers a host-maintained `dirtyAt`.
+
 ## 0.15.0
 
 ### Migrate

package/dist/game/playableGame.d.ts

@@ -340,6 +340,33 @@ export interface PresentationEffectsConfig {
     shake?: boolean;
 }
 /** How a screenshot host reaches live gameplay in this game — the data behind `shoot --mode play`. */
+/**
+ * One named framing in {@link GameCaptureConfig.views}: everything about a capture except the host-side
+ * viewport (`--device`, `--size`) and `--mode`, which the runner routes on before the game module loads.
+ * Every field mirrors the equivalent capture flag, and an explicit flag on the command line wins over the
+ * shot's value so a declared framing stays a starting point rather than a cage.
+ */
+export interface GameCaptureView {
+    /** One line naming what this shot is for — printed by `shoot <game> --list-views`. */
+    description?: string;
+    /** `--look`: `x,z`, `x,y,z`, `@marker:<id>`, or `@entity:<id>`. */
+    look?: string;
+    /** `--look-from`: `dist[,height[,angle]]`. */
+    lookFrom?: string;
+    /** `--spawn`: `x,y,z` or `x,y,z,yaw`, for a shot framed from the player's vantage instead of a detached camera. */
+    spawn?: string;
+    /** `--state`: a {@link GameCaptureConfig.states} entry to reach before capturing. */
+    state?: string;
+    /** `--run`: commands to dispatch before capturing, when the shot needs staging no declared state covers. */
+    run?: readonly string[];
+    /** `--settle`: milliseconds to wait before the frame, for a shot behind an animation. */
+    settleMs?: number;
+}
+/**
+ * How a game makes itself screenshottable: the commands that reach live play or a named screen, the
+ * framings worth re-capturing, and the progress metrics a bot playtest samples. Declaring these once
+ * is what lets a capture host reproduce a view instead of re-deriving it by hand every run.
+ */
 export interface GameCaptureConfig {
     /**
      * Commands run (in order, via `ctx.game.commands.run`) right after boot when a capture host requests the
@@ -363,6 +390,13 @@ export interface GameCaptureConfig {
         name: string;
         input?: unknown;
     })[]>;
+    /**
+     * Named framings worth re-capturing — the views a reviewer actually asks about (`street`, `keep-exterior`,
+     * `boss-arena`), each pinning the camera, the staging, and the settle for that shot. `shoot <game> --view <name>`
+     * reproduces one exactly, so a before/after pair is the same framing by construction instead of two hand-typed
+     * flag sets that drifted. An unknown name fails the capture listing the declared views.
+     */
+    views?: Record<string, GameCaptureView>;
     /** Extra milliseconds the capture host waits after `play` commands before taking the play-mode screenshot — cover an intro cinematic or spawn-in fade. Default 2500. */
     settleMs?: number;
     /** Bot-playtest read hook: maps live game state to a flat vector of numeric progress metrics the `drive --playtest` harness samples over time (e.g. `{ x, z, score, phase }`). Genre-agnostic — "progress" is whatever the game reports; the engine stays neutral. The harness watches these numbers move under scripted input: any metric changing beyond an epsilon counts as forward progress, all metrics flat past the softlock threshold under active input flags a softlock. Return every value that should count as advancing; omit to opt the game out of the playtest rung. */
@@ -422,6 +456,8 @@ export interface PlayableGame<TUi = unknown, TWorldOverlay = unknown, TRenderEnt
         statId?: string;
         roles?: readonly CatalogEntityRole[];
         maxDistance?: number;
+        /** Hide a bar when world geometry stands between the player and the entity. These bars are a screen-space overlay outside the depth buffer, so by default they draw through walls. Default false. */
+        occlude?: boolean;
     };
     /**
      * Opt in to billboarded nameplates (name + optional HP bar) floating over non-local entities — the

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.15.0";
+export declare const VERSION = "0.17.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,55 @@
 /** Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating. */
-export const VERSION = "0.15.0";
+export const VERSION = "0.17.0";
 /** Per-version engine changelog keyed by semver string (e.g. `"0.10.0"`). */
 export const CHANGELOG = {
+    "0.17.0": {
+        migrate: [
+            "Bump lockstep SDK packages to `^0.17.0`: `@jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}`. CLI `jgengine` is `0.14.0`; `@jgengine/github` is `0.4.0`.",
+            "A deleted player profile stays deleted. When a game persists players (`save.scope` includes `player`), hydrating a member with no `jgPlayerProfiles` row no longer falls back to the copy of their state kept on the server row \u2014 that copy was resurrected and then written back as authoritative, so a world reset that cleared profiles but not servers silently restored every player's old balance. A game whose save scope excludes players (`\"none\"`, `\"chunks\"`) is unchanged: the server-row copy is still their state. If you seed members onto a server row without going through `joinServer`, write their profile row too.",
+            "`slotsPerServer` is capped at 256 (`JG_MAX_MEMBERS_PER_SERVER`). `createGameServerFunctions` now throws at wiring time on a larger value instead of accepting it and failing at the write that overflows the document. One server is one Convex document holding the world row, the roster, and every member's session state; a bigger number was never a bigger world. Shard across servers, or move world state into `jgWorldChunks`.",
+            "The tick cron only sweeps games that declare `loop.onTick`. A game with no tick hook used to pay a full hydrate plus a full persist every second per running server, for a snapshot `runtime.tick` returned unchanged; it now costs nothing while idle. If you relied on the tick cron to autosave a hookless game, the 60s `flushDirtyServers` cron and the `flushSave` mutation still do it.",
+        ],
+        added: [
+            "`solidObstaclesNear` / `resolveWalkerStep` (`@jgengine/core/movement/solidObstacles`) \u2014 the engine's single answer to \"what is solid here\", now shared rather than re-derived per consumer. `solidObstaclesNear(ctx, position, reachX, reachZ)` returns the blocking physical colliders near a point through a bounded `inBox` broadphase; `resolveWalkerStep(ctx, position, stepX, stepZ)` slides a horizontal step against them with the player's axis-separated sliding. Reach for these instead of deriving obstacles from a game catalog's own solidity flags.",
+            "Bounded hydration and a client chunk read \u2014 `loadServerSnapshot(ctx, server, runtime, { players, chunkKeys })` hydrates only the members and chunks a mutation will touch instead of a document read per member plus one per chunk, and the generated `getChunks` query lets a client read chunk state by key (capped at `MAX_CHUNKS_PER_QUERY`). Chunks were the documented escape hatch for world state too large for one row, but reads were unbounded and clients could not see them at all, so moving geometry there made things worse. `getServerMeta` returns lobby state (status, member count, revision) without the world payload.",
+            "`@jgengine/core/runtime/worldChunks` \u2014 `chunkKeyAt` / `chunkCoordAt` / `chunkKeyOf` / `parseChunkKey` / `chunkKeysInRadius` at a declared cell size, plus `setChunk` / `updateChunk` / `deleteChunk`, which mark the key dirty so the host actually persists it. `chunkKey` was an opaque game-chosen string and the engine never wrote `dirty.chunks`, so every game reimplemented the coordinate mapping and a game that forgot to push a key silently never saved that chunk.",
+            "Placed objects cull to `replication.aoiRadius`. `objects` is the one large spatial replicated set and had no projector, so a world with a few thousand placements sent all of them to every viewer. It now joins the same area-of-interest policy as `entities` and `stats`. Unset `aoiRadius` still replicates everything.",
+            "`createGameServerFunctions({ matchmaking: \"singleton\" })` \u2014 one shared world per game: auto-match always targets the existing world and a join past capacity fails loudly, instead of quietly creating a second world the player would be alone in. `joinServer` also reconciles a stored `slotsPerServer`/`save` that has drifted from the host options, which previously made raising the option a no-op on worlds that already existed. `selectJoinTarget` (`@jgengine/core/runtime/hostPolicy`) is the pure decision behind it.",
+            "`GameRuntime.hasTick` reports whether a runtime declares `loop.onTick`, so any host's scheduler can skip a server whose tick is a no-op by construction.",
+        ],
+        changed: [
+            "Walking NPCs now stop at the geometry that stops the player. `wander`, `patrol`, and `ctx.scene.entity.moveToward` consulted no obstacles at all, so a pedestrian walked through the building the player cannot enter. All three now slide their step against the scene's blocking physical colliders \u2014 the same query `stepPlayerMovement` reads. A patrol's path state still advances on its own clock (an authored route is not rewound by contact), but the entity can no longer end a tick inside a solid. Pass `avoidSolids: false` to `moveToward` for a mover meant to ignore the world (a flier, a camera rig).",
+            "`@jgengine/assets` verify fails a model source that contributes no index entries. A model pack that has never been pulled is a pin nothing has ever checked \u2014 that is how a Street Pack archive sat in the catalogue titled \"Downtown City MegaKit\". Record why a pack is not pulled in the new `AssetSource.unpulled` string; materials and sprites pull on demand and are exempt.",
+            "`persistServerSnapshot` returns `boolean` and skips a write that would change nothing. Every subscriber of a query that read a server row re-receives the whole result when that document changes, so an unconditional write on the 1 Hz tick re-pushed the entire world to every client once a second whether or not anything moved. `ServerPersistPlan` gains `changed` (`serverState` / `sessionPlayers` / `revision` / `any`) for hosts that write field-by-field.",
+            "`sessionPlayers` is merged over the stored map, not rebuilt from the snapshot, and entries for non-members are pruned. This is what makes a partially hydrated snapshot safe to persist.",
+            "`tickActiveServers` is bounded to `maxServersPerTick` (default 32) servers per transaction, oldest tick anchor first, instead of pulling every running server of every game into one transaction. `flushDirtyServers` is bounded the same way.",
+        ],
+        removed: [
+            "Asset source `quaternius-downtown-city`. It was titled \"Downtown City MegaKit\" but pinned at the Street Pack archive, which ships Blends/FBX/OBJ only \u2014 a pull found no models. Nothing referenced it.",
+        ],
+    },
+    "0.16.0": {
+        migrate: [
+            "Bump lockstep SDK packages to `^0.16.0`: `@jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}`. CLI `jgengine` is `0.13.0`; `@jgengine/github` is `0.3.0`.",
+            "Placed objects now replicate. `objects` joined the always-on baseline snapshot modules, so `ctx.hydrate` replaces the client's placed object set with the host's, the way `entities` already did. A game whose peers all run the same authored placement is unaffected; a game that places props on the client only, after hydrate, must move that placement to the host or keep it out of `ctx.scene.object`.",
+        ],
+        added: [
+            "`worldHealthBars.occlude` / `WorldHealthBars`+`WorldNameplates` `occlude` prop. World bars and nameplates are a screen-space overlay drawn outside the WebGL depth buffer, so nothing in the scene can hide them and an enemy's health bar reads straight through the building it stands behind. Set `occlude: true` to drop a bar when world geometry blocks the line from the player to the entity. Default `false` preserves the always-visible behaviour every shipped game currently relies on.",
+            "`DustField` + `WeatherLayer` mode `\"dust\"` (`@jgengine/shell/weather`) \u2014 wind-borne particulate. `WeatherLayer` could only do `clear`/`rain`/`snow`/`mixed`, so an arid, volcanic, ashen, or blown-out world had no way to put anything in the air. Dust drifts on horizontal wind with a slow vertical bob rather than falling; `groundBias` packs density toward the surface, motes fade near the top of the volume so recycled ones do not pop against the sky, and faster motes ride higher. Set `dustAlways` to keep it in the air alongside rain or snow instead of replacing them. Defaults `DEFAULT_DUST_COUNT`/`DEFAULT_DUST_DENSITY` sit beside the rain and snow pair.",
+            "Authored `city` volumes render their near-LOD facades with a `BuildingKit`. `CityRules.buildingKit` names a kit; a game registers the bound art with `registerBuildingKit(kit)` from `@jgengine/shell/structures/buildingKitRegistry` and the scene document carries only the name, so a city stays portable and free of model paths. Unset or unknown names keep the palette blocks. This puts the whole `city` primitive \u2014 not just the `building()` feature \u2014 on the kit path.",
+            "`BuildingKit` from `@jgengine/core/world/buildingKit` binds a generated building's facade part slots to real models, so procedural buildings render as an instanced asset kit instead of untextured blocks. `defineBuildingKit({ parts: { wall: [\"Wall_A.glb\", \u2026] } })` maps a part kind \u2014 or a `${facade}.${kind}` slot \u2014 to ordered variants that `kit.variant` indexes, with `fit`/`offset`/`rotation`/`scale`/`tint`/`autoOrient` per variant. Kinds a kit leaves unbound keep rendering the palette block, so a partial kit is a valid kit, and `omit` drops a kind entirely. Pass one through `building({ kit })` or straight to `InstancedBuildings`; `buildingKitVariantCounts(kit)` feeds `generateBuilding` so its seeded picks span exactly the models the kit binds.",
+            "`generateBuilding`, `generateBuildingDistrict`, and `createBuildingConfig` are now documented public API (`@jgengine/core/world/buildings`) and appear in `capabilities.md` under `building-generator`.",
+            "`capture.views` on `defineGame` \u2014 named framings (`GameCaptureView`: `look`, `lookFrom`, `spawn`, `state`, `run`, `settleMs`) that `shoot <game> --view <name>` and `drive --view <name>` replay exactly, so a before/after pair is the same view by construction. `shoot <game> --list-views` prints what a game declares; an unknown name fails listing them, and any explicit capture flag still wins over the view's value.",
+            "`modelLoadIdleMs()` from `@jgengine/shell/render/modelLoad` reports how long the shared GLB loader has been idle (`0` while a model is in flight). Capture hosts wait on it instead of guessing a settle delay, so an establishing shot no longer races streaming models.",
+            "Per-instance state on placed objects \u2014 `SceneObject.state` (opaque `Record`), set through `ctx.scene.object.setState`/`patchState`/`place({ state })`. It survives move/rotate/setVisual, replicates and saves with the object, and round-trips as `RuntimeObjectRow.flags` via `toRuntimeObjectRow`/`fromRuntimeObjectRow` (`@jgengine/core/multiplayer`). A chest's locked flag or a machine's fill level no longer needs a game-owned map keyed by `instanceId`.",
+            "`slotInventory` is a working feature \u2014 `ctx.scene.object.slots` gives objects whose catalog entry declares it real per-instance container contents: `layout`/`state`/`count`, `put`/`take`, and `transferIn`/`transferOut` between a player inventory and the object, all validated against the declared slot count, `accepts` kind filter, and stack limits, with neither side mutated on a rejection. Contents live on `SceneObject.slots`, so they replicate and save with the placement.",
+            "`loadServerSnapshot` and `persistServerSnapshot` are public (`@jgengine/convex/server`), and `createGameServerFunctions` also returns `helpers` (`loadSnapshot`, `applyCommand`, `persistSnapshot`, `runCommand`) bound to the same runtimes and auth mode. A host mutation can now pair snapshot work with its own table writes in one transaction; the registered `runCommand` mutation delegates to `helpers.runCommand`, so there is one implementation.",
+        ],
+        changed: [
+            "`GeneratedBuilding`'s `kit` prop is now the `BuildingKit`; the per-part React escape hatch it used to name moved to `partRenderer`, so `kit` means the same thing on `GeneratedBuilding` and `InstancedBuildings`. Rename the prop if you passed a `BuildingKitRenderer`.",
+        ],
+        removed: [],
+    },
     "0.15.0": {
         migrate: [
             "Bump lockstep SDK packages to ^0.15.0: @jgengine/{core,react,ws,node,sql,convex,shell,editor,assets}. CLI jgengine is 0.12.0; @jgengine/github is 0.2.0.",

package/dist/movement/playerMovement.js

@@ -1,7 +1,7 @@
 import { applyHorizontalImpulses, applyMotionImpulses } from "../runtime/motionIntents.js";
 import { groundFieldFor, hasEnvironmentTerrain, sampleSlope } from "../world/terrain.js";
-import { resolveColliders } from "../scene/colliders.js";
 import { advancePlayerMotion, constrainStepToAxis, createEmptyMovementKeys, createPlayerMotionState, DEFAULT_OBSTACLE_PLAYER_RADIUS, obstacleSupportHeight, resolveMovementIntent, resolveObstacleStep, snapPositionToGrid, } from "./movementModel.js";
+import { solidObstaclesNear } from "./solidObstacles.js";
 import { approachYaw, steerYaw } from "./steering.js";
 import { advanceVoxelPlayer, createVoxelPlayerBody, } from "./voxelController.js";
 const DEFAULT_TURN_SPEED = 2.4;
@@ -50,10 +50,6 @@ function storeFor(ctx) {
         store = {
             players: new Map(),
             solids: { count: -1, set: new Set() },
-            obstacleReach: {
-                count: -1,
-                value: { horizontal: OBSTACLE_MAX_HALF_EXTENT, vertical: OBSTACLE_VERTICAL_FLOOR },
-            },
         };
         stores.set(ctx, store);
     }
@@ -209,7 +205,7 @@ export function stepPlayerMovement(ctx, userId, input, dt, tuning, heading) {
     const stepHeight = tuning.movement?.stepHeight ?? DEFAULT_PLAYER_STEP_HEIGHT;
     let obstacles = null;
     if (tuning.movement?.collideObjects !== false) {
-        obstacles = gatherMovementObstacles(ctx, store, player.position, stepX, stepZ);
+        obstacles = gatherMovementObstacles(ctx, player.position, stepX, stepZ);
         // While grounded, a box the player could simply step onto is a ledge, not a wall.
         const resolved = resolveObstacleStep(player.position, stepX, stepZ, obstacles, DEFAULT_OBSTACLE_PLAYER_RADIUS, airborne ? 0 : stepHeight);
         stepX = resolved.stepX;
@@ -301,172 +297,10 @@ 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;
 /**
- * Broadphase reach floor (XZ): the `inBox` query indexes objects by their center *point*, so the query
- * must extend past the player by at least the largest blocking-collider extent or a wide object's edge
- * is missed. Floored so default unit boxes stay covered.
+ * The player's blocking obstacles for this step, from the shared solid seam. A walking NPC calls
+ * `resolveWalkerStep` against the same query, so "solid" means one thing engine-wide.
  */
-const OBSTACLE_MAX_HALF_EXTENT = 4;
-/**
- * Hard cap on XZ broadphase reach. City lots ~12–17 m footprint need ~17–20 m after yaw expansion;
- * beyond that we refuse to grow the query into a city-wide box (and rely on the outer AABB of each
- * solid still blocking once its *center* is in range).
- */
-const OBSTACLE_HORIZONTAL_CAP = 22;
-/**
- * Vertical broadphase floor/cap. Player only needs nearby ground props / step-ups — never full tower
- * height. Using building height for Y was the Vice Isle pose killer: a 50 m tower turned `inBox` into
- * a 100³ empty cell walk every frame.
- */
-const OBSTACLE_VERTICAL_FLOOR = 3;
-const OBSTACLE_VERTICAL_CAP = 8;
-/**
- * Mesh compound `boxes` under this count are treated as intentional openings (archways). Above it we
- * walk against the outer fitted AABB only — solid city buildings often ship dense box soups that
- * multiply narrowphase cost without changing the blocked footprint.
- */
-const MOVEMENT_MESH_BOX_BUDGET = 12;
-/**
- * Largest blocking reach in the scene, split into horizontal vs vertical and hard-capped. Cached per
- * ctx and recomputed when the object count changes.
- */
-function obstacleReachFor(ctx, store) {
-    const objects = ctx.scene.object.list();
-    const cache = store.obstacleReach;
-    if (cache.count === objects.length)
-        return cache.value;
-    let horizontal = OBSTACLE_MAX_HALF_EXTENT;
-    let vertical = OBSTACLE_VERTICAL_FLOOR;
-    for (const object of objects) {
-        const set = ctx.scene.object.collidersOf(object.instanceId);
-        if (set === null)
-            continue;
-        for (const collider of resolveColliders(set)) {
-            if (!collider.blocks || collider.purpose !== "physical")
-                continue;
-            const shape = collider.shape;
-            const offset = shape.offset;
-            const ox = offset !== undefined ? Math.abs(offset[0]) : 0;
-            const oy = offset !== undefined ? Math.abs(offset[1]) : 0;
-            const oz = offset !== undefined ? Math.abs(offset[2]) : 0;
-            if (shape.kind === "sphere") {
-                horizontal = Math.max(horizontal, ox + oz + shape.radius);
-                vertical = Math.max(vertical, oy + shape.radius);
-            }
-            else {
-                // Horizontal bound sums both axes so any yaw of the box stays covered.
-                const h = shape.halfExtents;
-                horizontal = Math.max(horizontal, ox + oz + h[0] + h[2]);
-                vertical = Math.max(vertical, oy + h[1]);
-            }
-        }
-    }
-    const value = {
-        horizontal: Math.min(horizontal, OBSTACLE_HORIZONTAL_CAP),
-        vertical: Math.min(vertical, OBSTACLE_VERTICAL_CAP),
-    };
-    cache.count = objects.length;
-    cache.value = value;
-    return value;
-}
-/**
- * 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 + the scene's max blocking 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 a small `boxes` set, 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, store, position, stepX, stepZ) {
-    const reach = obstacleReachFor(ctx, store);
-    const reachX = Math.abs(stepX) + DEFAULT_OBSTACLE_PLAYER_RADIUS + reach.horizontal;
-    const reachZ = Math.abs(stepZ) + DEFAULT_OBSTACLE_PLAYER_RADIUS + reach.horizontal;
-    const min = [
-        position[0] - reachX,
-        position[1] - reach.vertical,
-        position[2] - reachZ,
-    ];
-    const max = [
-        position[0] + reachX,
-        position[1] + OBSTACLE_PLAYER_HEIGHT + reach.vertical,
-        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 a small sub-box set (openings), 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;
-    // Dense compound soups (city buildings) collapse to the outer fitted AABB for movement — openings
-    // only stay mesh-box accurate when the box count is small (arches, doorways).
-    if (shape.kind === "mesh" &&
-        shape.boxes !== undefined &&
-        shape.boxes.length > 0 &&
-        shape.boxes.length <= MOVEMENT_MESH_BOX_BUDGET) {
-        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],
-    };
+function gatherMovementObstacles(ctx, position, stepX, stepZ) {
+    return solidObstaclesNear(ctx, position, Math.abs(stepX) + DEFAULT_OBSTACLE_PLAYER_RADIUS, Math.abs(stepZ) + DEFAULT_OBSTACLE_PLAYER_RADIUS);
 }

package/dist/movement/solidObstacles.d.ts

@@ -0,0 +1,87 @@
+import type { GameContext } from "../runtime/gameContext.js";
+import { resolveColliders, type ResolvedCollider } from "../scene/colliders.js";
+import type { EntityPosition } from "../scene/entityStore.js";
+import { type CollisionObstacle } from "./movementModel.js";
+/** Largest blocking-collider extent in the scene, split so tower height cannot inflate the XZ query. */
+export interface ObstacleReach {
+    /** Max XZ center-to-face distance of any blocking collider (capped). */
+    horizontal: number;
+    /** Max vertical center-to-face distance of any blocking collider (capped, much tighter than H). */
+    vertical: number;
+}
+/**
+ * The slice of the scene's object store this query needs. Narrow on purpose: the scene context wires
+ * its own store here while it is still being constructed, and `ctx.scene.object` satisfies it as-is.
+ * @internal
+ */
+export interface SolidObstacleSource {
+    list(): readonly {
+        instanceId: string;
+        position: EntityPosition;
+        rotationY: number;
+    }[];
+    inBox(min: EntityPosition, max: EntityPosition): readonly {
+        instanceId: string;
+        position: EntityPosition;
+        rotationY: number;
+    }[];
+    collidersOf(instanceId: string): Parameters<typeof resolveColliders>[0] | null;
+}
+/** Mutable reach cache; one per source, invalidated by object count. @internal */
+export interface ObstacleReachCache {
+    count: number;
+    value: ObstacleReach;
+}
+/** A fresh {@link ObstacleReachCache} for a caller that owns its own source. @internal */
+export declare function createObstacleReachCache(): ObstacleReachCache;
+/**
+ * Largest blocking reach in the scene, split into horizontal vs vertical and hard-capped. Cached per
+ * ctx and recomputed when the object count changes — the broadphase box every consumer inflates by, so
+ * a wall wider than the query box can never be missed.
+ * @internal
+ */
+export declare function solidObstacleReach(ctx: GameContext): ObstacleReach;
+/** {@link solidObstacleReach} against a bare source and caller-owned cache. @internal */
+export declare function sourceObstacleReach(source: SolidObstacleSource, cache: ObstacleReachCache): ObstacleReach;
+/** One blocking collider as a {@link CollisionObstacle}: a compound `boxes` obstacle for a mesh collider
+ * carrying a small sub-box set (openings), 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.
+ * @internal */
+export declare function obstacleFromCollider(collider: ResolvedCollider, position: EntityPosition, rotationY: number): CollisionObstacle;
+/**
+ * Every blocking physical obstacle overlapping the box `position` ± `reachX`/`reachZ`, read from the
+ * scene's resolved colliders.
+ *
+ * This is the engine's single answer to "what is solid here". The player resolver, a walking NPC, and
+ * anything else that has to stop at a wall read it rather than deriving their own set — three
+ * divergent notions of solid (engine colliders / game catalog flags / nothing at all) is what let a
+ * pedestrian stroll through the building the player cannot enter.
+ *
+ * @capability solid-obstacles the one blocking-geometry query the player resolver and NPC movers share
+ */
+export declare function solidObstaclesNear(ctx: GameContext, position: EntityPosition, reachX: number, reachZ: number, height?: number): CollisionObstacle[];
+/** {@link solidObstaclesNear} against a bare source and an already-resolved reach. @internal */
+export declare function sourceObstaclesNear(source: SolidObstacleSource, reach: ObstacleReach, position: EntityPosition, reachX: number, reachZ: number, height?: number): CollisionObstacle[];
+/**
+ * Slide a walker's horizontal step against the same solid geometry that stops the player, returning the
+ * X/Z it may actually take this tick. A step into a wall is cut on the blocked axis and preserved on the
+ * other, exactly as {@link stepPlayerMovement} resolves the player's.
+ *
+ * Bounded by the same broadphase as the player's gather: one `inBox` query sized to this step, never a
+ * full-world scan, so it stays affordable per NPC per tick.
+ *
+ * @capability walker-solid-step slide an NPC's step against the geometry that blocks the player
+ */
+export declare function resolveWalkerStep(ctx: GameContext, position: EntityPosition, stepX: number, stepZ: number, options?: {
+    radius?: number;
+    stepUpHeight?: number;
+}): {
+    stepX: number;
+    stepZ: number;
+};
+/** {@link resolveWalkerStep} against an already-gathered obstacle set. @internal */
+export declare function slideStep(position: EntityPosition, stepX: number, stepZ: number, obstacles: readonly CollisionObstacle[], radius?: number, stepUpHeight?: number): {
+    stepX: number;
+    stepZ: number;
+};