@call-me-sensei/toonlab 0.4.21 → 0.4.23

package/agents/skills/claude/game-dev/SKILL.md

@@ -1,100 +1,76 @@
 ---
 name: game-dev
-description: Starting point for integrating ToonLab into an existing anime-style game or scene, including focused runtime routing, Gallery/MCP sourcing policy, and experimental/host-owned boundaries.
+description: Build a new playable game or integrate ToonLab into an existing Three.js game using public rendering, character, surface, collision, and asset workflows.
 ---
 
-# Integrating ToonLab into an Anime-Style Game
+# Develop a game with ToonLab
 
-Use this skill when an existing game, level, character, or scene spans more
-than one ToonLab system. Do not use it to promise a complete polished world
-from one prompt.
+Use this for game development and integration spanning several ToonLab systems.
+For a single shader or asset edit, use its focused skill. References beginning
+`agents/` are relative to the installed `@call-me-sensei/toonlab` package root.
 
-Read first:
-- `agents/references/anime-art-direction.md`
-- `agents/references/style-bundles.md`
-- `agents/references/mcp-asset-discovery.md`
-- `agents/references/asset-sourcing-policy.md`
-- `agents/references/runtime-entry-points.md`
+Read `agents/references/runtime-entry-points.md` for supported APIs. Read
+`agents/references/game-lifecycle.md` when wiring the renderer, movement,
+update loop, or teardown. Read art-direction/style references when applying a
+look, and `asset-sourcing` when asset discovery or generation is needed.
 
-## Assembly order
+## New game
 
-1. Inventory the supplied scene, approved cameras, existing asset/library
-   content, and the exact targets the developer wants ToonLab to change. Treat
-   layout, terrain, coastline, biome, lighting, camera, and gameplay
-   as protected host work unless the developer requests an experiment.
-2. Load the selected v2 bundle and its `artDirection`; use
-   `CALL_ME_SENSEI_STYLE_BUNDLE` when no other approved bundle is selected.
-3. Locate the asset-sourcing policy. Ask the developer when it is missing;
-   continue library-first in advisory mode only while reporting that decision.
-4. Feature-detect ToonLab OSS local and/or ToonLab Pro remote MCP. Reuse the
-   project/library first, search the released Gallery for named gaps, validate
-   finalists, then download only selected assets with provenance.
-5. Let the host game retain its renderer, scene layout, cameras, controls,
-   animation, physics, storage, and loading pipeline. When the same scene has
-   terrain-bound objects, grass, or shoreline water, create one
-   `createSceneSurfaceRuntime({ bounds, heightAt, waterLevel })`. The host owns
-   authored XZ layout and the terrain sampler; the surface runtime owns every
-   derived Y placement, bounds-grounding, water bed/shore wiring, and its
-   readiness audit. Never independently assign those values.
-   Label only the requested character, manufactured, tree, grass, flower,
-   ground, rock, water, and post targets.
-   When creating or modifying 3D content, also inventory every render material:
-   each slot needs a stable material ID and valid semantic role in the target's
-   versioned material contract. A root label alone never makes a multi-material
-   model bundle-ready.
-   Imported manufactured models should go through
-   `proposeManufacturedStyleTargetLabel()` and a reviewed proposal; every
-   low-confidence or generic entry needs an explicit override before
-   `applyManufacturedStyleTargetLabelProposal()` writes durable metadata.
-   Create one `createSceneStyleRuntime()` for the scene. Its default collision
-   runtime makes labeled manufactured, rock, prop, and tree targets solid;
-   generated trees use trunk geometry. Do not write parallel blocker arrays.
-6. Run `auditStyleBundleApplication()` and resolve every missing label, mixed
-   material, unsupported renderer, missing slot, or custom adapter before the
-   first mutation. Then call atomic `applyStyleBundle()`.
-7. Add focused procedural grass with `surface.createGrassField()`, ground
-   objects with `surface.place()`, and create shoreline Water with
-   `surface.createWaterSurface()`. This makes terrain sampling, water masking,
-   shoaling, nearshore phase, and persistent shore state the default. Do not
-   silently redesign the level to make a subsystem fit.
-8. Run `styleRuntime.collision.assertReady()`, report every target plan, and
-   probe representative tree, rock, and manufactured objects. Use explicit
-   collision metadata when bounds are inappropriate and the public Rapier
-   adapter when the host already owns a Rapier world. Then run
-   `surface.assertReady({ camera, styleRuntime, requireShadowDomains })`
-   after the shared shadow pass has rendered. A build, `castShadow` flag, or
-   target count is not proof of grounding, texture preservation, shoreline
-   wiring, or actual caster coverage. Then inspect the developer-supplied cameras plus relevant
-   close/far and lit/shadowed views. Iterate one material or asset family at a
-   time and report every remaining host or experimental gap.
+Implement the requested host game: input, camera, rules, HUD, level layout,
+dynamic physics or lightweight movement, and persistence if requested.
+Host-owned does not mean forbidden. Use ToonLab for the capabilities it
+actually exports; do not promise that a package call generates a finished world.
 
-## Runtime boundary
+Start with a playable vertical slice: move, collide, interact with one objective,
+and restart. Use simple host-authored geometry until the loop works. Replace
+placeholders with accepted assets and the chosen style incrementally. Record
+performance and visual checks at the gameplay camera, not just a flyover.
+The copyable `agents/examples/game-foundation.mjs` demonstrates a small
+host-authored loop with public ToonLab labeling, styling and static collision;
+it is an example, not a new package API or a full physics controller.
 
-The host render loop advances gameplay and explicitly installed scene systems,
-then renders once. Do not invent undocumented ToonLab imports. One-shot world
-generation; terrain/biome/coast/cliff formation; automatic set dressing;
-current Sky/Cloud composition; and full Lighting, Weather, Climate, VFX,
-camera, game-feel, navigation, physics, and streaming composition are
-experimental or host-owned.
+## Existing game
 
-Asset identity never belongs in a v2 style bundle. Strict tree and rock tests
-accept only project/ToonLab libraries or the ToonLab gallery. A similar-looking
-external or generated replacement is still denied under that policy.
+Inventory the existing renderer, loop, cameras, physics, loading and cleanup
+paths. Preserve them unless the task authorizes replacement. Integrate only the
+requested targets and avoid starting another animation loop. Use adapters for
+the host physics world and existing controllers rather than parallel systems.
 
-## Definition of done
+## Integrate the supported runtime
 
-- Every requested supported treatment routes to an explicit labeled target;
-  unused or experimental bundle slots are not a completion requirement.
-- Every render material on every created/imported target has a stable ID and
-  semantic role; incompatible atlas regions are split or carry an ID mask.
-- No raw PBR material escapes without the selected anime treatment.
-- Every used asset has stable ID, source class, provenance, license, anime-fit
-  review status, and a policy decision.
-- Supplied verification cameras pass the requested material, asset, vegetation,
-  water, shadow, and LOD checks without changing protected host composition.
-- `.toonlab/reports/style-asset-gaps.json` and `TOONLAB_ASSET_GAPS.md` exist
-  when custom work was required, and state what feedback is requested.
-- The consumer build and a real gameplay smoke test pass.
-- The shared scene-surface audit passes with no off-surface grass/objects,
-  disconnected water bed, missing shore state, lost source texture inputs,
-  invalid review camera, or incomplete required shadow domain.
+1. Resolve the installed package version, export map, and selected style bundle.
+   Call Me Sensei's bundle ID is `call-me-sensei`; domain selectors can differ.
+2. Create or reuse the host scene and renderer. Use `createCharacterRuntime()`
+   for supported loaded characters, and the walkable runtime when its movement
+   integration fits. Keep host input, movement intent and camera separate.
+3. If terrain placement and shoreline systems share a heightfield, provide its
+   world bounds and `heightAt(x, z)` once to `createSceneSurfaceRuntime()`.
+   Use its placement, grass and water helpers for that coordinated scene.
+   Ordinary rooms or flat arenas do not need a surface runtime.
+4. Assign stable target IDs, rendering domains, material IDs and roles. Use
+   `proposeManufacturedStyleTargetLabel()` and explicit reviewed corrections
+   for ambiguous imported materials; persist the accepted contract.
+5. Create one `createSceneStyleRuntime()` for the scene, then call its `apply()`
+   with the chosen bundle and labeled targets/discovery in strict mode. This
+   coordinates the renderer, lighting, ground field, shadows and static
+   collision. Resolve strict failures before application; do not bypass them
+   by calling an adapter directly.
+6. Use its default labeled static blockers and explicit collision metadata
+   where bounds are inappropriate. Prefer `createRapierCollisionAdapter()`
+   when integrating with an existing Rapier world. Do not maintain a second
+   blocker list for the same assets. Test real movement, not just flags.
+7. Assign one update owner per system and one final render owner. See the
+   lifecycle reference: style updates do not replace Sky, Water, grass or
+   character updates. When post is active, render through its documented path.
+8. Run `styleRuntime.collision.assertReady()`. For heightfield scenes, also run
+   `surface.assertReady({ camera, styleRuntime, requireShadowDomains })` after
+   the shared passes have rendered, scoped to the domains actually present.
+
+## Completion
+
+The requested gameplay loop, controls, camera, UI and restart work. Applicable
+build/type checks pass. Targets have complete material contracts; assets retain
+provenance and editable recipes. Inspect lit/shadowed and near/far views where
+relevant, and exercise startup, resize, pause/resume and disposal. Report
+remaining defects honestly. Do not require every optional ToonLab domain in a
+scene that does not use it, or treat user-approved host code as a package defect.

package/agents/skills/claude/lighting/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: lighting
+description: Integrate ToonLab's public lighting and scene-style runtime, diagnose shared shadows and sky alignment, and coordinate host-owned local lights.
+---
+
+# Lighting and shared shadows
+
+References beginning `agents/` resolve from the installed ToonLab package root.
+Read `agents/references/runtime-entry-points.md` and the selected bundle's
+art direction. Public imports are `@call-me-sensei/toonlab/lighting` and
+`@call-me-sensei/toonlab/styles`.
+
+Prefer `createSceneStyleRuntime({ renderer, scene, sky, water, post })` and
+`styleRuntime.apply(bundle, ...)` for a coordinated game scene. The public
+lighting bundle slot owns the supported sun/fill/probe settings; scene-style
+updates coordinate lighting, shared shadows and the ground field. Do not add
+an independent default directional rig that doubles the package key light.
+
+The host owns the time progression, authored local lights, camera and gameplay
+conditions. Use `styleRuntime.setTimeOfDay(hour)` to synchronize supported
+bound systems. Choose unique named override layers for independent live owners,
+and remove only the layer that owner created. Do not serialize composed state
+back over authored presets.
+
+Every relevant caster/receiver must participate in the shared shadow contract.
+Label targets, preserve cast/receive flags, and inspect the actual shared-pass
+coverage. Native `renderer.shadowMap` alone does not feed every ToonLab TSL
+receiver. If the host integrates focused APIs without scene-style ownership,
+explicitly wire the same light direction, shadow pass and scene-state adapters.
+
+Check the visible sky sun against the shadow direction, key/fill balance,
+near-white clipping, dark-material readability and relevant indoor/outdoor
+views. Frame shadow coverage around the area the game actually uses. Tune
+quality/resolution against a measured frame budget. Use additional coastal or
+underwater checks only when water is present. Record an integration gap only
+when the supported contract cannot meet the requested treatment.

package/agents/skills/claude/post-processing/SKILL.md

@@ -3,6 +3,10 @@ name: post-processing
 description: Help developers use ToonLab post-processing, bloom, color grade, LUT, vignette, outlines, depth cue, or motion blur.
 ---
 
+References beginning `agents/` resolve from the installed ToonLab package root
+(normally `node_modules/@call-me-sensei/toonlab/`), even when this skill is copied.
+
+
 # Post Processing
 
 Use this skill when a developer wants ToonLab's optional post-processing
@@ -22,9 +26,10 @@ Generating looks (no lab UI required):
 - `createPostGeneratorRecipe(id, { seed, locks, configuration })` defines an
   editable domain; `createGeneratedPostPresetDocument(recipe, { quality })`
   resolves it into a flat, portable preset deterministically per seed.
-- The packaged MCP server is reserved for asset discovery, provenance,
-  sourcing-policy decisions, and custom-gap records. Generate post profiles
-  in code and commit any resolved document that the project needs to retain.
+- MCP supports portable Lab document creation and mutation as well as asset
+  discovery. Inspect `get_lab_features` for the available Lab contract; use
+  code for procedural profile generation and keep any resolved document the
+  project needs to retain.
 - Ship the resolved preset in the app; keep the recipe only if runtime
   re-rolling is a feature.
 

package/agents/skills/claude/rock-ground-shaders/SKILL.md

@@ -3,6 +3,10 @@ name: rock-ground-shaders
 description: Apply, configure, and verify ToonLab rock and ground shaders in outdoor scenes, including textures, close detail, HDR sun response, cast/receive shadows, ground-field adoption, shoreline wet bands, and Call Me Sensei defaults.
 ---
 
+References beginning `agents/` resolve from the installed ToonLab package root
+(normally `node_modules/@call-me-sensei/toonlab/`), even when this skill is copied.
+
+
 # Rock and ground shaders
 
 Use this skill when terrain, cliffs, catalog rocks, beaches, or grass-ground
@@ -35,21 +39,12 @@ if (report.usedGeneratedTextures) {
 setRockShaderSceneState(rockRoot, { waterLevel });
 ```
 
-For the representative semantic hoodoo, validate before styling:
-
-```js
-import { inspectRockRegionBindings } from '@call-me-sensei/toonlab/rock-shader';
-
-const regions = inspectRockRegionBindings(hoodooRoot);
-if (regions.totalVertices !== 134981) throw new Error('Unexpected hoodoo binding');
-```
-
-The v1 binding is fixed to profile `hoodoo-caprock-normalized-height-v1` and
-channels `base/shaft/neck/cap`. Do not apply it to another family. Use only
-material styling (`detail: null`) on the annotated mesh; any position/topology
-edit requires semantic regeneration and rebaking. Prove repeated
-`applyRockShader()` / `restoreRockShader()` cycles restore exact material,
-texture, geometry, index, attribute, shadow, and user-data identities.
+For an asset with authored semantic regions, use `inspectRockRegionBindings()`
+and its matching versioned contract before styling. Do not copy region names
+or vertex-count assumptions from a single research fixture onto other rocks.
+Preserve authored masks and their geometry binding; topology/UV edits require
+updated bindings and any required rebakes. Qualify apply/revert cycles on the
+actual asset.
 
 `applyRockShader` sets `castShadow` and `receiveShadow` true by default.
 Override them only for an explicit rendering reason. It reports whether

package/agents/skills/claude/rockgen/SKILL.md

@@ -1,30 +1,61 @@
 ---
 name: rockgen
-description: Help developers use ToonLab procedural rock, cliff, heightfield, erosion, SDF, mesh, preset, sculpt, or GLB export tools.
+description: Create or edit ToonLab procedural rocks and portable rock recipes, including deterministic realistic surface maps, semantic masks, LOD, collision and export.
 ---
 
-# Rockgen
+# Procedural rocks and realistic surfaces
 
-Use this skill when a developer wants procedural rock, cliff, or heightfield
-generation; stylized erosion; SDF composition; surface-nets meshing; rock
-presets; sculpt edits; or GLB export.
+Use public `@call-me-sensei/toonlab/rockgen` for geometry and deterministic
+surface data, and `@call-me-sensei/toonlab/rock-shader` for reusable appearance.
+References beginning `agents/` resolve from the installed package root, even
+when this skill is copied. Read `agents/references/runtime-entry-points.md` and
+`rock-ground-shaders` for material application and shared shadow integration.
 
-Public imports:
-- `@call-me-sensei/toonlab/rockgen`
+## Geometry and sourcing
 
-Read first:
-- `README.md` feature table for the exported rockgen surface.
+Use the project's accepted sourcing policy. Strict anime sourcing admits
+library/gallery rocks; a newly generated procedural rock needs an explicitly
+permitted workflow. An explicit rock-authoring request is not a request for a
+complete terrain or automatic world builder. Keep the host's layout and game
+logic separate from the asset recipe.
 
-Developer guidance:
-- Use fixed seeds when an app needs repeatable generated assets.
-- Store app-specific presets or generated outputs in the host app's asset
-  pipeline, not in ToonLab sample folders.
-- Treat Rock Lab as an optional local authoring example, not a runtime
-  dependency.
-- Heightfield erosion is provided by ToonLab's first-party stylized erosion
-  path; do not advise developers to depend on the old terrain-editor fork or
-  third-party simulator.
+Use a fixed seed and stable asset ID. Preserve the geometry recipe, transforms,
+units, surface specification, LODs, collision and provenance in the host asset
+pipeline. Use MCP `get_lab_features` for the current portable document contract
+before `create_lab_document`; read the result's `document` field. Save to the
+Library when persistence is requested. Do not import Labs, repository compilers
+or fixture data into the consumer app.
 
-Verify:
-- In consumer apps, regenerate with the same preset/seed and compare the asset
-  shape or exported file the app expects.
+## Realistic material support
+
+The npm generator supports realistic rock surfaces without generative AI
+credits. Use `NATURAL_ROCK_SURFACE_PROFILES` to discover IDs and display labels,
+`createNaturalRockMapData` to produce deterministic channel data, and
+`createNaturalRockSurfaceSpecification` to persist its reproducible recipe.
+Display “Nature Reference Rocks” or the profile label, never internal production
+names. Do not replace a requested realistic finish with a stylized one.
+
+`result.maps` contains RGBA byte arrays for `baseColor`, `normalGL`, `roughness`,
+`ao`, `orm`, `smoothness` and `heightMicro`. The host constructs textures and
+assigns the projection: Base Color is sRGB, other maps are linear data. ORM is
+AO/roughness/metallic in R/G/B; metallic is zero. Preserve source UV mapping
+when applying baked maps. A shader profile alone does not load or bind maps.
+
+Homogeneous profiles need an explicit profile and seed. Mixed-material profiles
+also require authored semantic masks bound to the current geometry SHA-256.
+Persist the specification's encoded masks and hashes unchanged. Do not fabricate
+regions or discard masks on save, clone or MCP edits. Topology/UV changes need
+new bindings. Use 64–4096 maps for previews; production surface specifications
+require 1024–4096. Budget memory for all channels before choosing resolution.
+
+Micro-height describes material detail, not a signed high-to-low geometry bake.
+Geometry edits can invalidate LOD, collision, projection and bake provenance;
+regenerate affected outputs before declaring the variation ready.
+
+## Verify the asset
+
+Regenerate with the same recipe and compare shape/map hashes; save and reopen
+when persistence is part of the task. Inspect the requested finish, seams,
+silhouette, near/far transitions and shadows at relevant views. Check physical
+scale and collision by moving against the object. Use targeted runtime tests
+and rendered evidence; metadata alone is insufficient.

package/agents/skills/claude/scene-style-application/SKILL.md

@@ -3,6 +3,10 @@ name: scene-style-application
 description: Inspect, plan, apply, and verify ToonLab style bundles on labeled scenes without copying Lab or showcase code.
 ---
 
+References beginning `agents/` resolve from the installed ToonLab package root
+(normally `node_modules/@call-me-sensei/toonlab/`), even when this skill is copied.
+
+
 # Scene style application
 
 Ask the developer whether application should be **strict** or **advisory** before

package/agents/skills/claude/style-presets/SKILL.md

@@ -3,19 +3,23 @@ name: style-presets
 description: Explicitly select and record the intended ToonLab style or preset at every style-aware call site, distinguish neutral-default factories from Call Me Sensei-default factories, and audit overrides before reporting a custom integration note. Use before authoring environment, vegetation, grass, water, rock, ground, sky, cloud, or post settings, and whenever a subsystem looks unexpectedly unstyled.
 ---
 
+References beginning `agents/` resolve from the installed ToonLab package root
+(normally `node_modules/@call-me-sensei/toonlab/`), even when this skill is copied.
+
+
 # Name the preset
 
 This skill makes an individual call site explicit; it does not imply that every
 listed subsystem is part of a live Lab. Sky and Cloud focused authoring is live.
-Weather, Climate, and automatic full-world composition remain lower-level APIs
-for users who want to assemble those systems in their own application.
+Weather and Climate engines remain repository-only; agents may author host
+scene conditions without claiming unsupported npm entry points.
 
 Style-aware ToonLab factories take a `preset`, a `style`, or both. Some
 factories intentionally resolve a neutral/default treatment when the selector
 is omitted; Rock and Ground already default to Call Me Sensei, while
 Cloud has no named style at all since the volumetric rebuild retired them.
-Always pass the intended selector anyway so the call site and capture manifest
-are auditable. Never claim that every omitted selector falls back to neutral.
+Pass the intended selector where the API has one; do not invent a selector
+for a parameter-only API. Never claim that every omitted selector falls back to neutral.
 
 Omitting a selector on the neutral-default factories is one of the most
 expensive mistakes a ToonLab agent can make. In one capability test it hit
@@ -65,10 +69,9 @@ report against ToonLab before the cause was found:
 - A bare `createVegetationShaderScopeSettings()` plus ~25 hand-authored fields —
   three revisions of look development on the wrong base.
 
-So: **before overriding a preset field, state why the shipped value is wrong for
-this scene**, in a comment, naming the scene fact the shared IP treatment cannot
-know — plane extent, bed depth, camera distance, a specific art-direction target
-with a measured value. If you cannot name one, do not override it.
+Document meaningful overrides with the scene requirement they serve, such as
+bed depth, camera distance, material identity or the requested art direction.
+Routine art iteration is allowed; do not add an approval step for every value.
 
 ## When a subsystem looks wrong
 

package/agents/skills/claude/toon-shading/SKILL.md

@@ -3,6 +3,10 @@ name: toon-shading
 description: Help developers use ToonLab character toon shading, toon settings, presets, material roles, outlines, shadows, highlights, fur, or stickers.
 ---
 
+References beginning `agents/` resolve from the installed ToonLab package root
+(normally `node_modules/@call-me-sensei/toonlab/`), even when this skill is copied.
+
+
 # Toon Shading
 
 Use this skill when a developer wants ToonLab character toon materials, toon

package/agents/skills/claude/vegetation-sky/SKILL.md

@@ -3,6 +3,10 @@ name: vegetation-sky
 description: Help users apply ToonLab grass, flowers, trees, Tree/Grass/Flower shader profiles, and the live Sky/Cloud authoring surfaces to an existing scene.
 ---
 
+References beginning `agents/` resolve from the installed ToonLab package root
+(normally `node_modules/@call-me-sensei/toonlab/`), even when this skill is copied.
+
+
 # Vegetation, Sky, and Cloud
 
 Use these focused systems on an existing scene with host-supplied placements,
@@ -85,7 +89,7 @@ User guidance:
   MCP's `search_public_gallery` and `get_public_gallery_asset` tools, then
   instantiate its portable recipe with `StylizedTree`. Use `BranchTree` when
   the developer explicitly wants
-  recursive branching, five broadleaf silhouettes, leaf color/texture plus a
+  recursive branching and the supported `BRANCH_TREE_LEAF_SHAPES`, leaf color/texture plus a
   portable lit/shadow/crown palette, independent leaf `coverageScale`, bark
   color/texture, authored trunk bend/twist/taper, roots, portable documents,
   and the shared Tree Shader. `branches.children` counts lateral children;
@@ -104,7 +108,8 @@ User guidance:
   and use `trunkSurfaceProfile: 'none'` only for a deliberate flat-color art
   direction. Verify every trunk both casts and receives in shared-pass
   coverage telemetry.
-  Do not select, invent, or claim support for a botanical species. The large
+  Use supported morphology and texture controls for the requested appearance;
+  do not claim botanical fidelity from a named leaf shape alone. The large
   taxonomy/species roster visible in repository labs is experimental and is
   not a package API.
 - Author and route the independent `TREE_SHADER_PROFILE`,
@@ -118,8 +123,8 @@ User guidance:
 - Use the public versioned Grass, vegetation-shader, BranchTree/flower recipe, and Sky
   preset document APIs for portable data; do not copy lab-local validators.
 - Treat Sky as one integrated World System, not a separate Shader Lab. Its
-  shader, sun, clouds, stars, and procedural motion form one system preset with
-  exactly 46 portable art fields; dome radius and quality are not in it.
+  atmosphere, sun, cloud, night-sky, noise, god-ray and time blocks use the
+  current `SKY_PARAMS_FIELD_SCHEMA`; quality is a separate runtime choice.
 - Cloud is a raymarched volumetric deck. The painted source/composition/card
   pipeline was replaced outright: `createCloudSourceDocument`,
   `createCloudCompositionDocument`, `createCloudField` and
@@ -132,9 +137,10 @@ User guidance:
 - `sky.settings` is the authored baseline and `sky.renderedSettings` is the
   current named-layer composition. Give Lighting, Weather, and other scene
   owners unique `setSceneOverrideLayer` ids and clear only their own id.
-- For world integration, let the host game own the sun/light adapter. Lighting
-  is not a stable public package or bundle domain; coordinate project-local
-  lighting through explicit Sky, Weather, Water, and vegetation adapters.
+- For world integration, prefer `createSceneStyleRuntime()` and its public
+  lighting slot for the sun, probe and shared shadows. The host still owns
+  time progression and authored local lights. Coordinate custom scene inputs
+  through the documented adapters.
 - The composed-world sun adapter is `setSun({ direction, color, sky })`; it
   keeps the real light/shadows and Grass, Flower, Forest, Ambient FX, Sky, and
   Water scene inputs aligned without changing their portable presets.