@jgengine/shell 0.38.0 → 0.38.1

package/CHANGELOG.md

@@ -26,6 +26,25 @@ At publish, rename this heading to the new version and mirror the entries into
 `packages/core/src/meta/changelog.ts` (the typed `CHANGELOG` export).
 -->
 
+## 0.38.1
+
+### Migrate
+
+- **Bump lockstep SDK packages to `^0.38.1`:** `@jgengine/{core,rapier,react,ws,node,sql,convex,shell,editor,assets,navbake}`. CLI `jgengine` is `0.35.1`; `@jgengine/github` is `0.25.1`.
+- Nothing to migrate. `variantLevels()` was renamed to `ModelVariantConfig.shadows` before any release shipped it, so no published version ever exported it and no consumer can be holding one. A level that wants to stop paying the near level's shadow cost writes `{ url, shadows: "none" }`; leaving `shadows` out keeps the model's own answer.
+
+### Added
+
+- `ModelVariantConfig.shadows` (`@jgengine/core/world/modelLod`): a model variant level declares its own shadow participation as a plain field, `"inherit" | "cast" | "receive" | "both" | "none"`. `"inherit"`, the default, keeps the model's own `shadows`, so every existing model draws as before; a far level set to `"none"` leaves the shadow pass while still drawing its mesh.
+- `ModelShadowMode` (`@jgengine/core/world/modelLod`) names the four-value shadow vocabulary, and `ModelConfig.shadows` uses it.
+- `variantLevelModel` (`@jgengine/shell/render/singleVariantLod`) is the one place that resolves what a level draws and how it shadows; the single prop, batched prop and scatter paths all ask it, so a level's asset and its shadow answer cannot disagree.
+
+### Fixed
+
+- `SaveSlotsPane` cards are one box each: equal tracks, `grid-auto-rows: 1fr`, a card edge that reads over a bright scene, and a name that ellipsises instead of widening the card. A save with a long name and one with none produce the same card box.
+- `GameMenu` puts the primary verbs on their own scrim, so their labels stay legible over whatever the live scene is showing instead of relying on a text shadow.
+- The theme emits three menu tokens the slot card and the verb surface read: `--jg-menu-card-height` (`clamp(244px, 27vh, 300px)`), `--jg-menu-card-thumb` (`clamp(88px, 14vh, 160px)`) and `--jg-menu-surface-radius` (`8px`). A game overrides them in its own `HudTheme` instead of patching the menu components.
+
 ## 0.38.0
 
 ### Migrate

package/dist/render/SceneModels.js

@@ -17,7 +17,7 @@ import { useFootIk } from "./useFootIk.js";
 import { resolveRigNode } from "./rigNode.js";
 import { PartMotionRig } from "./PartMotion.js";
 import { syncSpriteFrame } from "./spriteRender.js";
-import { singleVariantLevel, singleVariantModel } from "./singleVariantLod.js";
+import { singleVariantLevel, variantLevelModel } from "./singleVariantLod.js";
 import { applyMaterialOverride } from "../materialOverride.js";
 import { applyPaintTextureToMaterials, cacheStandardMaterials, cloneModelScene, createPaintCanvas, disposeModelScene, ownModelMaterial, disposePaintCanvas, syncPaintCanvas, } from "./modelRender.js";
 export function EntitySprite({ sprite }) {
@@ -123,7 +123,7 @@ export function SingleVariantModel({ model, instanceId, measure, }) {
         if (next !== level)
             setLevel(next);
     });
-    const drawn = useMemo(() => singleVariantModel(model, level), [model, level]);
+    const drawn = useMemo(() => variantLevelModel(model, level), [model, level]);
     // The near level owns the measured bounds and collision mesh, like the batched path: a decimated
     // asset must not redefine what the catalog entry collides as.
     return _jsx(EntityModel, { model: drawn, instanceId: instanceId, measure: level === 0 ? measure : undefined });

package/dist/render/singleVariantLod.d.ts

@@ -2,12 +2,19 @@ import type * as THREE from "three";
 import type { ModelConfig } from "@jgengine/core/game/playableGame";
 import type { ModelVariantSelector } from "@jgengine/core/world/modelLod";
 /**
- * The model an isolated prop draws at one variant level: that level's asset and no nested variants, so
- * a prop rendered on its own switches assets the way a batched instance does. Out-of-range levels clamp
- * to the nearest one, and a model without variants is returned untouched.
+ * Shadow participation the model draws with at one level: the level's own choice when it made one,
+ * otherwise the model's `shadows` untouched.
  * @internal
  */
-export declare function singleVariantModel(model: ModelConfig, level: number): ModelConfig;
+export declare function variantLevelShadows(model: ModelConfig, level: number): ModelConfig["shadows"];
+/**
+ * The model any path draws at one variant level: that level's asset, its shadow participation, and no
+ * nested variants, so a prop rendered on its own, a batched instance and a scatter cell all switch
+ * the same way. Out-of-range levels clamp to the nearest one, and a model without variants is
+ * returned untouched.
+ * @internal
+ */
+export declare function variantLevelModel(model: ModelConfig, level: number): ModelConfig;
 /**
  * Metres from the camera's world position to a placement, written through the caller's scratch vectors
  * so a frame allocates nothing.

package/dist/render/singleVariantLod.js

@@ -1,15 +1,36 @@
+function levelOf(model, level) {
+    const levels = model.variants?.levels;
+    if (levels === undefined)
+        return undefined;
+    return levels[Math.min(levels.length - 1, Math.max(0, level))];
+}
 /**
- * The model an isolated prop draws at one variant level: that level's asset and no nested variants, so
- * a prop rendered on its own switches assets the way a batched instance does. Out-of-range levels clamp
- * to the nearest one, and a model without variants is returned untouched.
+ * Shadow participation the model draws with at one level: the level's own choice when it made one,
+ * otherwise the model's `shadows` untouched.
  * @internal
  */
-export function singleVariantModel(model, level) {
-    const levels = model.variants?.levels;
-    if (levels === undefined)
+export function variantLevelShadows(model, level) {
+    const chosen = levelOf(model, level)?.shadows;
+    return chosen === undefined || chosen === "inherit" ? model.shadows : chosen;
+}
+/**
+ * The model any path draws at one variant level: that level's asset, its shadow participation, and no
+ * nested variants, so a prop rendered on its own, a batched instance and a scatter cell all switch
+ * the same way. Out-of-range levels clamp to the nearest one, and a model without variants is
+ * returned untouched.
+ * @internal
+ */
+export function variantLevelModel(model, level) {
+    const chosen = levelOf(model, level);
+    if (chosen === undefined)
         return model;
-    const chosen = levels[Math.min(levels.length - 1, Math.max(0, level))];
-    return { ...model, url: chosen.url, variants: undefined };
+    const shadows = variantLevelShadows(model, level);
+    return {
+        ...model,
+        url: chosen.url,
+        variants: undefined,
+        ...(shadows === undefined ? {} : { shadows }),
+    };
 }
 /**
  * Metres from the camera's world position to a placement, written through the caller's scratch vectors

package/dist/scatter/InstancedScatter.js

@@ -8,6 +8,7 @@ import { chunkScatterInstances } from "@jgengine/core/world/scatterRegion";
 import { beginFallbackSeam, reportFallbackSeam } from "@jgengine/core/devtools/fallbackSeams";
 import { createModelVariantSelector } from "@jgengine/core/world/modelLod";
 import { CAMERA_POST_FRAME_PRIORITY } from "../camera/cameraRigs.js";
+import { variantLevelModel } from "../render/singleVariantLod.js";
 import { buildScatterProxy } from "./scatterProxies.js";
 import { buildScatterModelSources, disposeScatterModelSources } from "./scatterModels.js";
 import { writeScatterVariantLevel } from "./scatterVariants.js";
@@ -120,9 +121,8 @@ function ScatterVariantLevel({ model, url, level, selector, batches }) {
         loader.setMeshoptDecoder(MeshoptDecoder);
     });
     const { sources, root } = useMemo(() => {
-        const levelModel = { ...model, url, variants: undefined };
-        return buildScatterModelSources(gltf.scene, levelModel);
-    }, [gltf, model, url]);
+        return buildScatterModelSources(gltf.scene, variantLevelModel(model, level));
+    }, [gltf, model, level]);
     useEffect(() => () => disposeScatterModelSources(root), [root]);
     return (_jsx(_Fragment, { children: sources.map((source, sourceIndex) => batches.map((batch) => (_jsx(ScatterVariantSourceInstances, { source: source, batch: batch, level: level, selector: selector }, `${batch.key}:${sourceIndex}`)))) }));
 }

package/dist/world/StaticObjectModels.js

@@ -7,6 +7,7 @@ import { devtools } from "@jgengine/core/devtools/devtools";
 import { useGameContext } from "@jgengine/react/provider";
 import { sharedGltfLoader } from "../render/modelLoad.js";
 import { IsolatedModelPart } from "../render/SceneModels.js";
+import { variantLevelModel } from "../render/singleVariantLod.js";
 import { freezeStaticTransforms } from "../render/staticTransforms.js";
 import { measureLocalBounds, reportMeasuredBounds } from "../render/measureBounds.js";
 import { measureLocalCollisionTriangles, reportMeasuredCollisionMesh } from "../render/measureCollisionMesh.js";
@@ -174,7 +175,7 @@ export function VariantStaticObjects({ batch, single }) {
     const { objects, excluded } = useBatchMembers(batch);
     const levels = batch.model.variants.levels;
     const selector = useMemo(() => createModelVariantSelector(batch.model.variants), [batch.model]);
-    return _jsxs(_Fragment, { children: [levels.map((level, index) => (_jsx(VariantLevel, { url: level.url, model: { ...batch.model, url: level.url, variants: undefined }, batch: batch, objects: objects, level: index, selector: selector, measure: index === 0, single: single }, `${level.url}:${index}`))), excluded.map((id) => { const live = ctx.scene.object.get(id); return live === null ? null : single(live); })] });
+    return _jsxs(_Fragment, { children: [levels.map((level, index) => (_jsx(VariantLevel, { url: level.url, model: variantLevelModel(batch.model, index), batch: batch, objects: objects, level: index, selector: selector, measure: index === 0, single: single }, `${level.url}:${index}`))), excluded.map((id) => { const live = ctx.scene.object.get(id); return live === null ? null : single(live); })] });
 }
 /** Render compatible authored or `scenery` props as shared model draws, preserving unsupported models. @internal */
 export function StaticObjectModels({ batch, single }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgengine/shell",
-  "version": "0.38.0",
+  "version": "0.38.1",
   "description": "Game player shell for JGengine: React Three Fiber canvas, orbit camera, input tracking, HUD mounting, GameUiPreview, and a demo game. Consumers supply a GameRegistry.",
   "license": "Apache-2.0",
   "type": "module",
@@ -39,9 +39,9 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@jgengine/core": "^0.38.0",
-    "@jgengine/react": "^0.38.0",
-    "@jgengine/ws": "^0.38.0"
+    "@jgengine/core": "^0.38.1",
+    "@jgengine/react": "^0.38.1",
+    "@jgengine/ws": "^0.38.1"
   },
   "peerDependencies": {
     "@react-three/drei": "^10.0.0",

package/skills/jgengine/api.md

@@ -6,7 +6,7 @@
 
 - `CHANGELOG` (const): const CHANGELOG: Record<string, ChangelogEntry> — Per-version engine changelog keyed by semver string (e.g. `"0.10.0"`).
 - `ChangelogEntry` (interface): interface ChangelogEntry — One release's migrate steps plus added/changed/removed notes (typed mirror of CHANGELOG.md).
-- `VERSION` (const): const VERSION: "0.38.0" — Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating.
+- `VERSION` (const): const VERSION: "0.38.1" — Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating.
 
 ## @jgengine/core/authoring
 
@@ -285,7 +285,7 @@
 
 - `CHANGELOG` (const): const CHANGELOG: Record<string, ChangelogEntry> — Per-version engine changelog keyed by semver string (e.g. `"0.10.0"`).
 - `ChangelogEntry` (interface): interface ChangelogEntry — One release's migrate steps plus added/changed/removed notes (typed mirror of CHANGELOG.md).
-- `VERSION` (const): const VERSION: "0.38.0" — Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating.
+- `VERSION` (const): const VERSION: "0.38.1" — Installed `@jgengine/core` semver — compare against {@link CHANGELOG} keys when migrating.
 
 ## @jgengine/core/runtime/adapter
 

package/skills/jgengine-world/api.md

@@ -2655,7 +2655,7 @@
 - `ModelAssetRef` (interface): interface ModelAssetRef { url: string; anchor?: "center" | "origin"; dims?: ModelDims; collisionMesh?: CollisionMeshData; space?: AssetSpace; clips?: readonly string[] } — ⚠ undocumented · used by `createHostedWorldSessionAsync` (@jgengine/core/runtime/hostedWorldSession): Build a hosted session from an asynchronous persistence backend.
 - `ModelDims` (interface): interface ModelDims — Measured horizontal footprint, footprint center, and lowest Y of a model in model space.
 - `ModelNode` (interface): interface ModelNode — Generic named-socket reader for loaded 3D models. Walks a node tree (any object with `.name`, `.position`, and `.children` — structurally satisfied by `THREE.Object3D`) and collects the local offsets of nodes whose name marks an attachment point. Genre-agnostic: wire anchors on a pylon, muzzle/hand mounts on a character, hardpoints on a ship, seat/decal slots on furniture — anything an artist tags with an empty in the GLB. Pure data (no three.js import), so it lives in core.
-- `ModelVariantConfig` (interface): interface ModelVariantConfig — One mesh level of a {@link ModelVariantLodConfig}: a full or decimated GLB and how far it draws.
+- `ModelVariantConfig` (interface): interface ModelVariantConfig — One mesh level of a {@link ModelVariantLodConfig}: a full or decimated GLB, how far it draws and how it shadows.
 - `ModelVariantLodConfig` (interface): interface ModelVariantLodConfig — Ordered mesh detail levels for one model, switched per instance by camera distance. The first level is the full mesh the model's own `url` names; every later level is a cheaper asset. A tree line uses this so near trees keep their full mesh while far ones draw a decimated copy of the same species.
 - `ModelVariantSelector` (interface): interface ModelVariantSelector — Per-instance distance switch over a model's detail levels: one answer per id, held across a boundary until the instance clears it.
 - `ModelVariantSelectorState` (interface): interface ModelVariantSelectorState — Plain JSON state of a {@link ModelVariantSelector}: each id's current level index.
@@ -4041,7 +4041,8 @@
 ## @jgengine/core/world/modelLod
 
 - `DEFAULT_VARIANT_HYSTERESIS` (const): const DEFAULT_VARIANT_HYSTERESIS: 6 — Metres an instance must travel past a switch boundary before it changes level unless the model declares its own.
-- `ModelVariantConfig` (interface): interface ModelVariantConfig — One mesh level of a {@link ModelVariantLodConfig}: a full or decimated GLB and how far it draws.
+- `ModelShadowMode` (type): type ModelShadowMode = "cast" | "receive" | "both" | "none" — How a model, or one of its variant levels, takes part in the shadow pass.
+- `ModelVariantConfig` (interface): interface ModelVariantConfig — One mesh level of a {@link ModelVariantLodConfig}: a full or decimated GLB, how far it draws and how it shadows.
 - `ModelVariantLodConfig` (interface): interface ModelVariantLodConfig — Ordered mesh detail levels for one model, switched per instance by camera distance. The first level is the full mesh the model's own `url` names; every later level is a cheaper asset. A tree line uses this so near trees keep their full mesh while far ones draw a decimated copy of the same species.
 - `ModelVariantSelector` (interface): interface ModelVariantSelector — Per-instance distance switch over a model's detail levels: one answer per id, held across a boundary until the instance clears it.
 - `ModelVariantSelectorState` (interface): interface ModelVariantSelectorState — Plain JSON state of a {@link ModelVariantSelector}: each id's current level index.