incanto 0.52.0 → 0.54.0

package/editor/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Incanto Scene Editor</title>
     <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'><rect width='16' height='16' rx='3' fill='%236ee7dc'/><text x='8' y='12' text-anchor='middle' font-size='11' font-family='monospace' fill='%230e1018'>i</text></svg>" />
-    <script type="module" crossorigin src="./assets/index-Cb5Brupb.js"></script>
+    <script type="module" crossorigin src="./assets/index-BYfiwbQx.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/GameServer-C56iOUgF.js">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incanto",
-  "version": "0.52.0",
+  "version": "0.54.0",
   "description": "Vibe-coding-first web game engine SDK — JSON-driven scenes on three.js",
   "keywords": [
     "game-engine",

package/schemas/scene.schema.json

@@ -352,6 +352,9 @@
         {
           "$ref": "#/$defs/UiLanguageSelect"
         },
+        {
+          "$ref": "#/$defs/UiMuteToggle"
+        },
         {
           "$ref": "#/$defs/UiPanel"
         },
@@ -373,6 +376,9 @@
         {
           "$ref": "#/$defs/UiToggle"
         },
+        {
+          "$ref": "#/$defs/UiVolumeSlider"
+        },
         {
           "$ref": "#/$defs/VoxelGrid3D"
         },
@@ -4229,6 +4235,10 @@
               "type": "boolean",
               "default": true
             },
+            "worldSpace": {
+              "type": "boolean",
+              "default": false
+            },
             "rate": {
               "type": "number",
               "default": 40
@@ -4437,6 +4447,10 @@
               "type": "boolean",
               "default": true
             },
+            "worldSpace": {
+              "type": "boolean",
+              "default": false
+            },
             "rate": {
               "type": "number",
               "default": 40
@@ -6870,6 +6884,97 @@
       },
       "required": ["name", "type"]
     },
+    "UiMuteToggle": {
+      "type": "object",
+      "x-signals": ["dragStarted", "dragCancelled", "droppedOn", "dropped", "changed"],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "uid": {
+          "type": "string"
+        },
+        "type": {
+          "const": "UiMuteToggle"
+        },
+        "groups": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "tags": {
+          "type": "object"
+        },
+        "props": {
+          "type": "object",
+          "properties": {
+            "anchor": {
+              "type": "string",
+              "enum": [
+                "topLeft",
+                "top",
+                "topRight",
+                "left",
+                "center",
+                "right",
+                "bottomLeft",
+                "bottom",
+                "bottomRight"
+              ],
+              "default": "topLeft"
+            },
+            "visible": {
+              "type": "boolean",
+              "default": true
+            },
+            "focusable": {
+              "type": "boolean",
+              "default": true
+            },
+            "draggable": {
+              "type": "boolean",
+              "default": false
+            },
+            "dropTarget": {
+              "type": "boolean",
+              "default": false
+            },
+            "label": {
+              "type": "string",
+              "default": ""
+            },
+            "value": {
+              "type": "boolean",
+              "default": false
+            }
+          },
+          "additionalProperties": false
+        },
+        "script": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            },
+            "props": {
+              "type": "object"
+            }
+          },
+          "required": ["name"]
+        },
+        "network": {
+          "type": "object"
+        },
+        "children": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/node"
+          }
+        }
+      },
+      "required": ["name", "type"]
+    },
     "UiPanel": {
       "type": "object",
       "x-signals": ["dragStarted", "dragCancelled", "droppedOn", "dropped"],
@@ -7580,6 +7685,122 @@
       },
       "required": ["name", "type"]
     },
+    "UiVolumeSlider": {
+      "type": "object",
+      "x-signals": ["dragStarted", "dragCancelled", "droppedOn", "dropped", "changed"],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "uid": {
+          "type": "string"
+        },
+        "type": {
+          "const": "UiVolumeSlider"
+        },
+        "groups": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "tags": {
+          "type": "object"
+        },
+        "props": {
+          "type": "object",
+          "properties": {
+            "anchor": {
+              "type": "string",
+              "enum": [
+                "topLeft",
+                "top",
+                "topRight",
+                "left",
+                "center",
+                "right",
+                "bottomLeft",
+                "bottom",
+                "bottomRight"
+              ],
+              "default": "topLeft"
+            },
+            "visible": {
+              "type": "boolean",
+              "default": true
+            },
+            "focusable": {
+              "type": "boolean",
+              "default": true
+            },
+            "draggable": {
+              "type": "boolean",
+              "default": false
+            },
+            "dropTarget": {
+              "type": "boolean",
+              "default": false
+            },
+            "label": {
+              "type": "string",
+              "default": ""
+            },
+            "value": {
+              "type": "number",
+              "default": 0.5
+            },
+            "min": {
+              "type": "number",
+              "default": 0
+            },
+            "max": {
+              "type": "number",
+              "default": 1
+            },
+            "step": {
+              "type": "number",
+              "default": 0.01
+            },
+            "width": {
+              "type": "number",
+              "default": 180
+            },
+            "color": {
+              "type": "string",
+              "default": "#6ee7dc"
+            },
+            "bus": {
+              "type": "string",
+              "enum": ["master", "sfx", "music"],
+              "default": "master"
+            }
+          },
+          "additionalProperties": false
+        },
+        "script": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            },
+            "props": {
+              "type": "object"
+            }
+          },
+          "required": ["name"]
+        },
+        "network": {
+          "type": "object"
+        },
+        "children": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/node"
+          }
+        }
+      },
+      "required": ["name", "type"]
+    },
     "VoxelGrid3D": {
       "type": "object",
       "x-signals": ["blocksChanged"],

package/skills/incanto-assets.md

@@ -146,6 +146,47 @@ Swap in real art later by changing ONLY the `assets{}` entry — node props
 stay untouched.
 
 
+## Art you named and never copied
+
+`bunx incanto-check` warns when a scene asset points at a local file the project
+does not contain:
+
+```
+  ok  src/game.scene.json
+      warn: $hero → assets/hero.png is not in the project (looked in public/,
+      ./, and beside the scene). It will draw nothing.
+```
+
+That used to be a browser-only failure — visible in `assetErrors()`, which needs
+a running game and someone to look at it — and it is the single most common way
+a scene draws nothing. Remote (`https:`) and inline (`data:`) urls are left
+alone: the command cannot know, and guessing would be worse than the bug.
+
+## A spritesheet grid that does not fit says so
+
+`frameWidth`/`frameHeight` are the two numbers nothing could check for you, and
+getting them wrong does not fail — it draws the wrong art. A size that does not
+divide the sheet slices every row a little further off centre; an animation
+naming a frame past the end of the grid reads whatever is at the wrong end of
+the image.
+
+Both are reported now, once, the first time the sprite draws:
+
+```
+[incanto] spritesheet 'hero' does not fit its frame size: 1344 px wide is not a
+whole number of 100 px frames (672, 448, 336, 224, 192, 112 would divide it).
+Every row after the first is cut off centre.
+
+[incanto] spritesheet 'hero' has 35 frames (0–34), and an animation asks for
+frame 40. Those frames draw whatever is at the wrong end of the sheet.
+```
+
+The suggested sizes are the ones that actually divide your image, so the fix is
+usually in the message. `bunx incanto-assets info <name>` prints the real frame
+size for a built-in, and the editor's 📚 picker fills it in from the catalog's
+metadata — or leaves it BLANK when the catalog does not carry it, because an
+invented frame size is exactly this bug.
+
 ## Textures are shared automatically (3D)
 
 A hundred `Sprite3D`s pointing at one atlas cost **one** fetch, one decode and
@@ -162,9 +203,11 @@ Two consequences worth knowing:
 - **`pixelArt: true` also turns mipmaps off**, which is what makes pixel art stay
   crisp at distance instead of blurring into mud.
 
-A texture that 404s now shows up in `game.assetErrors()` alongside models, by the
+A texture that 404s shows up in `game.assetErrors()` alongside models, by the
 URL you wrote — so "why is my sprite invisible" is answerable without opening the
-network tab. In **2D** the same question is `renderer.assets.errors()`
+network tab. **That includes vegetation**: a `Tree3D` leaf or bark URL that fails
+used to leave a grove of bare branches and say nothing anywhere, because that
+node keeps its own texture cache. In **2D** the same question is `renderer.assets.errors()`
 (`$ref`, url and reason per failed entry), and the scene EDITOR reads it: a
 failed asset is red in the explorer with the url in its tooltip and the
 consequence in its inspector.

package/skills/incanto-audio.md

@@ -33,7 +33,9 @@ Set `preset` to one of the names below and call `play()`. No files, no loading.
 ```
 
 ```ts
-const coin = scene.tree.root.getNode('Coin'); // an AudioPlayer
+import type { AudioPlayer } from 'incanto';
+// from a Behavior — `getNode` returns a `Node`, so name the type you asked for
+const coin = this.node.getNode('Coin') as AudioPlayer;
 coin.play();   // synthesizes + plays instantly; rapid calls OVERLAP (no cutoff)
 ```
 
@@ -145,8 +147,20 @@ presets are fire-and-forget one-shots: they do not emit `finished`.
 Browsers block audio before the first user gesture. `autoplay: true` (or any
 early `play()`) that gets blocked is marked pending; **`createGame2D` /
 `createGame3D` automatically retry every pending player AND resume the WebAudio
-SFX context on the first pointerdown/keydown** — you don't wire anything. A
-blocked play is not an error; it just waits for the gesture.
+SFX context on the first gesture anywhere on the page** — you don't wire
+anything, and a tap on the on-screen touch controls counts (they sit above the
+canvas, not on it). A blocked play is not an error; it just waits.
+
+**A file the browser CANNOT play is a different thing, and it says so.** A 404 or
+an undecodable clip used to be filed as "waiting for a gesture" too, so it
+retried forever in silence — and a quiet game looks exactly like a game with no
+sound in it. Now it lands in the engine log and in
+**`game.assetErrors()`** (which 2D games can also ask now), beside the textures
+and models that 404'd:
+
+```
+[incanto] AudioPlayer 'Boom' could not load '/audio/explosion.mp3' — it is silent.
+```
 
 ### Music: loop a `src` clip on the music bus
 
@@ -227,7 +241,26 @@ the node declares (default `sfx`); music-ish loops typically set `bus: "music"`.
 Changes apply to currently-playing `src` clips on the next frame and to every new
 sound immediately.
 
-A settings slider just writes these numbers — no per-node bookkeeping.
+A settings slider just writes these numbers — no per-node bookkeeping. And
+**the slider is a node**, so an audio menu is scene JSON like everything else:
+
+```json
+{ "name": "Options", "type": "UiPanel", "props": { "anchor": "center" }, "children": [
+  { "name": "Music", "type": "UiVolumeSlider", "props": { "bus": "music" } },
+  { "name": "Sound", "type": "UiVolumeSlider", "props": { "bus": "sfx" } },
+  { "name": "Mute",  "type": "UiMuteToggle" }
+] }
+```
+
+| node | prop | writes |
+|---|---|---|
+| `UiVolumeSlider` | `bus`: `master` (default) / `sfx` / `music` | `engine.audio[bus]` |
+| `UiMuteToggle` | — | `engine.audio.muted` (checked = silent) |
+
+No behavior, no `connections`, nothing to save: the buses persist themselves
+(below), and each control follows a change made anywhere else, so two menus can
+never disagree. Left unlabelled a slider names its own bus (`Volume` / `Sound` /
+`Music`, translated when the scene declares `settings.volume.*`).
 
 ---
 
@@ -312,15 +345,44 @@ clean fit; the looping-`src` `AudioPlayer` (§2) stays the right tool for a *fix
 background loop authored in scene JSON. Wire `crossfadeTo` from gameplay:
 
 ```ts
-// e.g. in a behavior when the boss spawns:
-this.tree.engine.music.crossfadeTo('incanto/assets/audio/boss.mp3', 3);
+// e.g. in a behavior when the boss spawns (`this.engine` is the accessor a
+// Behavior has — there is no `this.tree`):
+this.engine.music.crossfadeTo('/audio/boss.mp3', 3);
 ```
 
-> Large music files are NOT bundled — reference them by URL (see §4). Headless:
-> the manager's state machine still runs (`current` updates) but plays nothing.
+> Large music files are NOT bundled — reference them by URL (see §4).
+
+**Headless the state machine still runs and `current` still updates** — nothing
+plays, but the question a test has is answerable:
+
+```ts
+session.engine.music.crossfadeTo('/audio/boss.wav', 2);
+session.step(100);
+session.engine.music.current;            // '/audio/boss.wav'
+session.engine.audio.countOf('/audio/boss.wav');  // 1
+```
 
 ---
 
+## Sound stops when the thing making it goes away
+
+Teardown is SILENCE, and you do not wire it:
+
+- **A freed node stops its clip.** Swap to level 2 and level 1's looping
+  background `AudioPlayer` stops with it — it used to play on over the new level
+  forever, with its node freed and no handle left to stop it. Being *moved* is
+  not this: a reparented node keeps playing, because reparenting is not
+  destroying.
+- **`game.dispose()` stops the music and every continuous voice**, and hands the
+  AudioContexts back. An SPA that mounts the game a few times would otherwise
+  run out of them (browsers allow only a handful per page).
+
+So the one thing you still own is a voice you want to outlive a node — and the
+one thing you must NOT rely on is a sound stopping itself because the scene
+changed under it. `engine.music` deliberately survives a scene swap (it belongs
+to the engine, not the scene): call `engine.music.stop(1)` or `crossfadeTo` when
+the music should change.
+
 ## Decision guide
 
 - **Need a quick game sound (coin/jump/hit/explosion/…)** → set `preset`. Done.
@@ -332,8 +394,33 @@ this.tree.engine.music.crossfadeTo('incanto/assets/audio/boss.mp3', 3);
 - **3D sound that pans + fades with distance** → `spatial:true` on an
   `AudioPlayer` in a 3D scene (§2b); listener = the active `Camera3D`.
 - **Global volume / mute / settings** → `engine.audio.master/sfx/music/muted`.
-- **Verifying headlessly** → audio is a no-op in the VM; assert `play()` doesn't
-  throw and check your gameplay/score logic instead (see incanto-verifying).
+- **Verifying headlessly** → read the AUDIO RECORD (below). Audio makes no sound
+  in the VM, but the calls still happen, so "did the coin sound fire when the
+  coin was collected?" is answerable there.
+
+## Verifying sound without hearing it
+
+```ts
+const session = await createPlaySession(gameJson, {});
+session.engine.audio.clearLog();
+collectACoin();
+session.step(200);
+
+session.engine.audio.countOf('coin');   // 1
+session.engine.audio.recent();
+// [{ kind: 'preset', name: 'coin', from: '/Game/Player/Coin', bus: 'sfx', at: 1.2 }]
+```
+
+`recent()` is the last 200 sounds, oldest first — `kind` is `preset` | `src` |
+`music` | `voice`, `name` is the preset name, the clip url or the track,
+`from` is the node path (or `engine.music` / `engine.sfx`), and `bus` is where
+its volume comes from. `countOf(name)` is the assertion you usually want;
+`clearLog()` resets between steps.
+
+This covers every path: `AudioPlayer.play()` on both the procedural and the
+`src` route, `engine.music.play`/`crossfadeTo`, and `engine.sfx.startVoice`. It
+records the INTENT to play — that the wiring fired — not that a speaker moved;
+for "the file is broken" see `assetErrors()` above.
 
 ## Settings that survive a reload (`engine.settings`)
 

package/skills/incanto-building-2d-games.md

@@ -200,9 +200,26 @@ listing the valid set. With a viewport design, UI coordinates are design px.
   **incanto-audio.md**.
 - Reference example: [examples/2d-phaser-sprite-character-gravity](https://github.com/rareboe/Incanto/tree/main/examples/2d-phaser-sprite-character-gravity) —
   spritesheet character with a walk/jump/attack behavior state machine.
-- Pointer→world mapping (the InputMap covers keyboard actions; pointer projection is
-  this one-liner):
-  `world = camera.clampedCenter(w,h) + (pointer - viewport/2) / camera.zoom`.
+- **Tap / drag / click**: `createGame2D({ pointer: true })` attaches pointer
+  input — MOUSE, FINGER and pen alike — and then
+
+  ```ts
+  game.engine.updated.connect(() => {
+    if (!game.engine.input.mouseJustPressed()) return;
+    const at = game.engine.input.pointerPosition();   // canvas px, null until
+    if (!at) return;                                  // a pointer has been seen
+    const world = game.renderer.worldFromScreen(at.x, at.y);   // world px
+    popAt(world);
+  });
+  ```
+
+  Use `renderer.worldFromScreen` — do NOT hand-roll the projection. It already
+  accounts for the design `viewport`, the letterbox bars and the camera's
+  clamped centre; a formula written against the DESIGN rect is off by
+  `(design − canvas) / 2 / zoom`, which on a 390 px-wide phone showing a 480 px
+  design measured **62 world px** — a finger-and-a-half from what the player
+  touched. Its inverse, `renderer.screenFromWorld(wx, wy)`, pins DOM to the
+  world (see incanto-web-integration).
 
 ## Game flow recipes
 
@@ -274,6 +291,41 @@ solid core carries the colour). `rate: 0` +
 { "signal": "finished", "from": "Boom", "to": ".", "handler": "onBoomDone" }
 ```
 
+### Where a particle LIVES: `worldSpace`
+
+A particle is born in the emitter's LOCAL space by default, so the whole plume
+moves with the node — right for a torch on a moving platform, wrong for almost
+everything else:
+
+- dust under a running player is GLUED to the player instead of left behind;
+- and the standard way to place a one-shot — move the emitter, `replay()` —
+  drags the PREVIOUS burst across the level with it.
+
+`"worldSpace": true` makes a particle keep the place it was born:
+
+```jsonc
+{ "name": "Dust", "type": "Particles2D",
+  "props": { "preset": "smoke", "worldSpace": true } }
+```
+
+It follows a moving PARENT too, not just the node's own position. Default is
+`false` so existing scenes look exactly as they did.
+
+### Armed, but not yet: `emitting: false`
+
+A one-shot with `burst` fires on its FIRST FRAME — which is what you want for a
+firework that is meant to go off as the level opens, and not at all what you
+want for the twenty explosions authored on twenty destructible crates. Set
+`"emitting": false` to arm one and hold it:
+
+```jsonc
+{ "name": "Boom", "type": "Particles2D",
+  "props": { "preset": "explosion", "rate": 0, "burst": 60, "emitting": false } }
+```
+
+`node.replay()` fires it — that is the game asking, so `emitting: false` does
+not hold it back — and re-arms it for the next time.
+
 `node.replay()` re-arms a one-shot. Simulation is deterministic under the
 engine seed — runScript verifies particle gameplay reproducibly.
 

package/skills/incanto-building-3d-games.md

@@ -463,7 +463,9 @@ block.
 ## Particles
 
 `Particles3D` mirrors `Particles2D` (same presets — `fire`, `explosion`,
-`magic`… and the same one-shot `rate: 0` + `burst` → `finished` pattern) as
+`magic`… the same one-shot `rate: 0` + `burst` → `finished` pattern, and the
+same `worldSpace` prop, which is what stops a moved one-shot dragging the
+previous explosion across the level) as
 point sprites in meters: preset distances auto-scale ÷100 (presets are authored
 in 2D px). See incanto-building-2d-games for the full prop list.
 

package/skills/incanto-environment.md

@@ -1042,7 +1042,9 @@ emitter only when you want a specific custom burst:
 
 (`replay` re-arms the one-shot burst; a small behavior can also move the
 emitter to the body first — the signal hands you the node:
-`onEntered(body) { splash.position = body.position; splash.replay(); }`.)
+`onEntered(body) { splash.position = body.position; splash.replay(); }` — give
+that emitter `"worldSpace": true`, or the second splash drags the first one to
+the new spot.)
 
 ## River3D — running water
 

package/skills/incanto-gameplay-behaviors.md

@@ -815,12 +815,59 @@ import { CameraShake, Cooldown, hitStop, screenFlash } from 'incanto/gameplay';
   meters). For cameras WITHOUT a follow script attach the standalone
   `CameraShake` behavior — it composes with any other position writer and
   returns the camera exactly to base.
-- **screenFlash(color?, opacity?, seconds?)** — full-screen damage/pickup
-  flash (DOM, headless no-op).
+- **screenFlash(engine, color?, opacity?, seconds?)** — full-screen damage/
+  pickup flash. DOM, so it draws nothing headless — but it REPORTS (below), so
+  you can still check that it fired.
 - **hitStop(engine, seconds?)** — freezes `engine.timeScale` for REAL
-  seconds then restores; stacked calls extend. Sells melee impacts.
+  seconds then restores; stacked calls extend. Sells melee impacts. It measures
+  those seconds on `engine.unscaledTime`, so it thaws in a headless session
+  exactly as it does in a browser.
 - **engine.timeScale** — 1 realtime, 0.5 slow motion, 0 pause: scales
-  variable AND fixed updates together (physics, timers, behaviors).
+  variable AND fixed updates together (physics, timers, behaviors) — and it
+  means the same thing headless, so a pause menu and a slow-motion finish can be
+  tested. (A stepped frame still HAPPENS while paused: `update` runs with
+  `dt = 0`, which is how the pause menu's own key polling keeps working.)
+
+## Did the effect fire?
+
+Sound has `engine.audio`; vision has **`engine.effects`**, and the question is
+the same one. `framing()` says where an emitter IS — a particle system that
+never fired and one that fired a hundred times sit at the same coordinates — and
+shake, flash and hit-stop draw nothing at all in a run with no screen.
+
+```ts
+session.engine.effects.clearLog();
+smashTheCrystal();
+session.step(200);
+
+session.engine.effects.countOf('explosion');            // 1
+session.engine.effects.countFrom('/Game/Crystal/Boom'); // 1
+session.engine.effects.recent();
+// [{ kind: 'burst', name: 'explosion', from: '/Game/Crystal/Boom', amount: 60, at: 1.2 }]
+```
+
+- `kind` — `burst` (a one-shot fired) · `emit` (a continuous emitter STARTED —
+  once, not once per particle) · `trail` (a `Trail3D` started laying ribbon) ·
+  `shake` · `flash` · `hitstop`.
+- `name` — the particle preset, or the flash colour.
+- `from` — the node path, or `engine` for the screen-wide ones.
+- `amount` — particles in the burst, shake magnitude, seconds frozen.
+- Bounded at 200, `clearLog()` between assertions.
+
+A `Trail3D`'s ribbon is a special case worth knowing: it is laid in the RENDER
+pass, because each point needs the node's real world transform (a sword arc is a
+rotating parent). So `trail.pointCount` is **0 headless** — that is the verify VM
+working, not a broken trail — and the `trail` event above is what tells you the
+wiring fired.
+
+It records that the effect was ASKED FOR, not that a pixel moved — the burst
+that never happened because the signal was never connected looks exactly like
+the burst that happened off-screen, and this tells them apart. For "is it
+running right now", a particle node also has **`aliveCount`**.
+
+A shake suppressed by `reduceMotion` records NOTHING, on purpose: it did not
+happen, and saying it did would send you hunting a camera bug that is an
+accessibility setting.
 
 ## Game flow (win / lose / restart)
 

package/skills/incanto-hud.md

@@ -151,6 +151,13 @@ so structure in the tree becomes structure on screen. Panels nest.
 | `UiSlider` | `label`, `value`, `min`, `max`, `step`, `width`, `color` | `changed(value)` |
 | `UiToggle` | `label`, `value` | `changed(bool)` |
 | `UiSelect` | `label`, `options` (`"low,medium,high"`), `value` | `changed(value)` |
+| `UiVolumeSlider` | `bus` (`master`/`sfx`/`music`), plus every `UiSlider` prop | `changed(value)` |
+| `UiMuteToggle` | `label` | `changed(bool)` |
+
+The last two are **already wired**: they read and write `engine.audio`, which
+persists itself. An audio menu is three nodes and no TypeScript — see
+`incanto-audio.md`. The graphics ones (`UiQualitySelect`, `UiFrameCapSelect`,
+`UiRenderScaleSelect`) and `UiLanguageSelect` work the same way.
 
 **An inventory is a grid panel**: `"layout": "grid", "columns": 5`, one child per
 slot, each a small `UiPanel` holding a `UiImage` (`tint` greys out what you