diff --git a/CHANGELOG.md b/CHANGELOG.md
index c660e5b..b2c32ff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,21 @@
 
 All notable changes to this package. Versions follow [Semantic Versioning](https://semver.org/).
 
+## Unreleased
+
+### Story products
+
+- Story loading, playback and authoring use `nnnotes.product/1` manifests with shared object resources and language-specific UI and fonts.
+- Home and live-result stories resolve their host prefabs, room geometry, Spine materials and animation bindings by object identity.
+- Data validation checks the story product graph, font bindings, shader variants, audio files and model dependencies. `--lang` selects an explicit language scope.
+- Node story loading accepts a manifest or a product layout containing exactly one story.
+
+### Bug fixes
+
+- Keep Spine index uploads from changing another renderer's vertex array.
+- Keep model and shared-object validation caches independent.
+- Clear loading text after language changes and display configured audio volumes in the controls.
+
 ## [0.1.7](https://github.com/empty-sekai/ournotes-player/compare/v0.1.6..v0.1.7) — 2026-10-14
 
 ### Features
@@ -159,5 +174,3 @@ All notable changes to this package. Versions follow [Semantic Versioning](https
 - add performance.md: the CPU cost of a frame
 - a file holds each controller and clip once; the validator checks every reference _(story)_
 
-
-
diff --git a/docs/data-format.md b/docs/data-format.md
index b24b525..55861fd 100644
--- a/docs/data-format.md
+++ b/docs/data-format.md
@@ -965,3 +965,9 @@ exactly the files the viewer and the story player read.
 
 It needs Node.js 22 or later and no dependencies. The opt-in data tests (`OURNOTES_DATA=<dir> npm run test:data`) go
 further and run lives and charts through the player in Node (see [CONTRIBUTING.md](../CONTRIBUTING.md)).
+
+## Song and replay data
+
+The song catalog example reads `music-data.json` with format `nnnotes.music-data/1`. Replay presets read
+`nnnotes.deck-data/1` for the caller-provided deck capabilities, and the replay worker accepts
+`nnnotes.replay-manifest/1` references. These are separate inputs from the live, model and story product manifests.
diff --git a/docs/fidelity.md b/docs/fidelity.md
index e68e9cb..f442652 100644
--- a/docs/fidelity.md
+++ b/docs/fidelity.md
@@ -528,7 +528,6 @@ Every `ENGINE:` note in `src/`, by file. `npm test` checks that this list matche
 - the ambient probe of a Flat ambient is built natively from the ambient colour; a white Flat ambient is taken as
 - the default reflection of a Skybox-mode scene without a skybox material (and without a custom cube) is taken
 - unity_LightData (native per-object light data): x the offset of the per-object light indices (0), y their
-- atlas page texture import settings are not in the data; bilinear, clamped, no mipmaps here.
 - a Skybox clear without a skybox material clears to the background colour.
 
 **`src/story/simple/home/room.js`**
diff --git a/docs/story-author.md b/docs/story-author.md
index 2d91e83..9515e21 100644
--- a/docs/story-author.md
+++ b/docs/story-author.md
@@ -11,7 +11,7 @@ The tool is experimental: the script format and the commands may change between
 ## Requirements
 
 - Node.js 22 or later.
-- A story site with stories in the model manifest format (`ournotes.story-manifest/2`) and its `models.json`
+- A story site with stories in the story product format (`nnnotes.product/1`) and its `models.json`
   ([story-data-format.md](story-data-format.md)). Pass it with `--site <dir>` or set `OURNOTES_SITE`.
 - For pictures (`render`, `base --out`, `model --out`): Chrome, Chromium or Edge. The tool starts a headless browser
   of its own with a temporary profile and ends it when the command ends. It draws with SwiftShader (WebGL2 on the
@@ -181,10 +181,11 @@ long auto mode then keeps the line before the next one (`_waitTalkTextUnitTime`
 
 ### build
 
-`build <script> --name <name>`: writes the story into the site as `custom-stories/<name>.json`, a story manifest of
-format `ournotes.story-manifest/2` (advId 0, the script's language only), and adds its own files to `assets/`: the
-compiled `story.json`, `episode.json` and `ui/fonts.json`. Every other file is the base story's or a model's, already
-in the site. A script with errors is not built.
+`build <script> --name <name>` writes `custom-stories/<name>.json`, a `story` product manifest
+(`nnnotes.product/1`, subject `0`) for the script's language. It adds the compiled `story.json`, `episode.json` and
+browser-font `fonts.json` to `assets/`, plus a content-addressed font product manifest under `storyfonts/`.
+The part index refers to the base story's reusable scene, UI, stages and cue sheets, and the cast's model manifests.
+A script with errors is not built.
 
 ### serve
 
@@ -278,7 +279,7 @@ Codes with a known fix are listed under [Fixes](#fixes).
 The tool compiles a script into the story player's data ([story-data-format.md](story-data-format.md)): an
 `episode.json` of the game's command rows (Character, Stage, Bgm, In, Out, Focus, FadeOut, FadeIn, Location, Motion,
 Expression, Talk) with the texts in its text table, a `story.json` naming the models and the music it plays, and the
-base story's `ui/fonts.json` with every font asset drawn by the browser
+base story's font product with every font asset drawn by the browser
 ([browser fonts](story-data-format.md#browser-fonts)): every character of the font family shows, laid out by
 TextMeshPro's rules with the base story's font settings. The other files (stages, talk window, shaders, the player
 settings, the music) are the base story's; the media of its own rows (frames, stills, effects, chat, videos) are left
diff --git a/docs/story-data-format.md b/docs/story-data-format.md
index a87d5b9..a81e80c 100644
--- a/docs/story-data-format.md
+++ b/docs/story-data-format.md
@@ -1,717 +1,272 @@
 # Story data format
 
-The story player plays one story episode (a scripted scene with Live2D characters, stages, talk text, voices and
-music) from a set of **logical files** that the embedding page supplies, usually as a static **site** served over
-HTTP, the same kind of site that serves charts and Live2D models ([data-format.md](data-format.md)). This document
-describes the story part of that data: the site layout, the story index, the story manifest with its per-language file
-groups, the Live2D models it uses, and every logical file as far as the player reads it. Producing the data is outside
-this repository; the [nnnotes](https://github.com/MetaSekaiLab/nnnotes) toolkit produces it from game files the user
-supplies (`nnnotes web SITE --story <id>` / `--all-stories`).
-
-Machine-readable schemas are in [`schema/`](../schema): [stories.schema.json](../schema/stories.schema.json),
-[story-manifest.schema.json](../schema/story-manifest.schema.json), [story.schema.json](../schema/story.schema.json),
-[episode.schema.json](../schema/episode.schema.json), [story-fonts.schema.json](../schema/story-fonts.schema.json) and
-[story-language.schema.json](../schema/story-language.schema.json). `node scripts/validate-data.mjs <site dir>` checks
-the stories of a site along with its charts and models (see [Validation](#validation)).
-
-Keys that are not described here are ignored by the player; producers may add their own. The conventions of the chart
-data apply unchanged ([Conventions](data-format.md#conventions): Unity names, Unity space, float32 values, `1e999`
-for infinity, UTF-8). Where a structure comes from the game's Unity data (prefabs, materials, clips, volume profiles),
-this document names it and the keys the player reads rather than every serialized field.
-
-Contents:
-[Site layout](#site-layout) ·
-[stories.json](#storiesjson) ·
-[Story manifest](#story-manifest) ·
-[Loading a story](#loading-a-story) ·
-[Logical files](#logical-files) ·
-[story.json](#storyjson) ·
-[episode.json](#episodejson) ·
-[scene.json](#scenejson) ·
-[Sounds](#sounds) ·
-[Live2D models](#live2d-models) ·
-[Story UI](#story-ui-uiuijson) ·
-[Fonts](#fonts-uifontsjson) ·
-[Language](#language-uilanguagesjson) ·
-[Media files](#media-files) ·
-[Documents and identities](#documents-and-identities) ·
-[Validation](#validation)
+A story is a `story` product whose `story.json` names its scene, media, models, sound sheets, UI and fonts. Each part
+is a product manifest (`nnnotes.product/1`) with its own files and retained Unity objects. The format uses the
+[shared object and file contracts](data-format.md#products).
 
-## Site layout
-
-```
-<site>/
-  stories.json                     story index (for listings; the player does not need it)
-  stories/<advId>.json             story manifest, one per story
-  stories/<region>/<advId>.json    a region's own manifest of a story (a site of several regions)
-  models.json, models/<id>.json    the Live2D models, the stories' among them (data-format.md "Live2D models")
-  story/                           the story page and the story bundle, when the site was built with them
-  assets/<sha256>.<ext>[.gz|.br]   file contents, content-addressed, shared with the charts and models
-```
-
-- Assets follow the rules of the products ([Products](data-format.md#products)): `<sha256>` is the lowercase
-  hex SHA-256 of the (decoded) bytes, `<ext>` the extension of the logical file, identical contents are stored once,
-  and an asset may be stored gzip- or brotli-encoded. Stories share the shaders, stage textures, cue sheets, UI
-  textures and glyph pages they have in common, and the model manifests of the models they use.
-- Asset and model manifest paths in a story manifest are relative to the site root. A player that loads a manifest by
-  URL finds the site root through the manifest's `root` (`../` for `stories/<advId>.json`, `../../` for
-  `stories/<region>/<advId>.json`).
-- `<advId>` is the story's episode id (a decimal integer, the game's `MasterAdv` id).
+The player loads one language at a time. Serialized component fields stay on their prefab nodes, while documents
+name objects by `<serialized file>:<path id>`. Materials and textures resolve by identity; a display name need not
+be unique. Game resources are supplied by the user.
 
-## stories.json
+| Document | Schema |
+|---|---|
+| Story product manifest | [story-manifest.schema.json](../schema/story-manifest.schema.json) |
+| Part index, `story.json` | [story.schema.json](../schema/story.schema.json) |
+| Command rows, `episode.json` | [episode.schema.json](../schema/episode.schema.json) |
+| Scene, `scene.json` | [story-scene.schema.json](../schema/story-scene.schema.json) |
+| UI, `ui.json` | [story-ui.schema.json](../schema/story-ui.schema.json) |
+| Simple UI, `ui.json` | [story-simple-ui.schema.json](../schema/story-simple-ui.schema.json) |
+| Host, `host.json` | [story-host.schema.json](../schema/story-host.schema.json) |
+| Media, `asset.json` | [story-asset.schema.json](../schema/story-asset.schema.json) |
+| Fonts, `fonts.json` | [story-fonts.schema.json](../schema/story-fonts.schema.json) |
+| UI language settings | [story-language.schema.json](../schema/story-language.schema.json) |
+| Listing index, `stories.json` | [stories.schema.json](../schema/stories.schema.json) |
 
-The index of the stories a site offers ([schema](../schema/stories.schema.json)). Story listings read it; the player
-does not.
+## Site layout
 
-```json
-{ "format": "ournotes.stories/1", "language": "en", "languages": ["ja", "en", "zh-Hant", "zh-Hans", "ko"],
-  "regions": [ { "id": "tw", "name": "…" } ],
-  "stories": [ { "id": "10462", "advId": 10462, "manifest": "stories/10462.json",
-                 "asset": "adv_script_…", "sheetName": "adv_script_…", "playbackMode": 0,
-                 "titles": { "ja": "…", "en": "…", "…": "…" },
-                 "groups": [ { "kind": "chapter", "id": 1001, "episodeNumber": 1,
-                               "chapter": { "id": 10, "names": { "ja": "…", "…": "…" }, "bandId": 1 },
-                               "characters": [] } ],
-                 "commands": ["Bgm", "Character", "…"], "commandCount": 412,
-                 "language": "en", "languages": ["ja", "en", "zh-Hant", "zh-Hans", "ko"],
-                 "audio": true, "audioFormat": "aac", "fonts": "open",
-                 "size": { "common": 20413220, "models": 9741091, "languages": { "ja": 410233, "…": 0 } },
-                 "regions": ["tw"] } ] }
+```text
+assets/<sha256>.<ext>
+stories/<advId>.json
+storyscenes/default.json
+storyassets/<asset>.json
+storyui/<language>.json
+storyfonts/<advId>_<language>.json
+storysimpleui/<language>.json
+storyhosts/<host>.json
+models/<model>.json
+cuesheets/<sheet>.json
+videos/<video>.json
+crilips/default.json
+rooms/<room>.json
+spots/<spot>.json
+stories.json
+models.json
 ```
 
-| Key | Type | Meaning |
-|---|---|---|
-| `format` | `"ournotes.stories/1"` | Version of this document. |
-| `language` | string | Optional. The default language of a listing. |
-| `languages` | string[] | Optional. The languages the entries' `titles` and language groups are in, in the order `ja`, `en`, `zh-Hant`, `zh-Hans`, `ko`. |
-| `regions` | object[] | Optional. The regions the site serves (as in [charts.json](data-format.md#chartsjson): `id`, `name`, `languages`). |
-| `stories` | object[] | One entry per manifest, sorted by `advId`, then `manifest`. |
-
-An entry holds the manifest's [story facts](#story-facts) and:
+Manifest paths and asset paths are relative to the product layout root. A story manifest may set `root`, relative
+to its URL: `../` for `stories/7.json`, `../../` for `stories/tw/7.json`. Without `root`, the loader uses `../`.
+The loader's `base` option overrides that root. Content-addressed files may use gzip or brotli; their entries record
+both decoded `size` and compressed `stored` length.
 
-| Key | Type | Meaning |
-|---|---|---|
-| `id` | string | The `advId` as a decimal string. |
-| `manifest` | string | Path of the story manifest, relative to the site root. |
-| `size` | object | `common`: the sum of `size` over the manifest's `files`; `models`: the sum of `size` over the files of the model manifests it lists and of their objects (an object several of them list counted once); `languages`: per language, the sum over that language group's `files` (decoded sizes, before shared assets are deduplicated). |
-| `regions` | string[] | Optional. The regions the manifest serves (the manifest's `regions`). An entry without it serves every region. |
-| `audio`, `audioFormat`, `fonts` | | Copies of the manifest keys of the same name. |
+## stories.json
 
-Languages are the game's text languages: `ja`, `en`, `zh-Hant`, `zh-Hans`, `ko`. A site of several regions follows
-the chart rules ([Several regions](data-format.md#several-regions)): a story id appears at most once per region, a
-listing shows the entries whose `regions` include the chosen region (and those without `regions`). The story list page
-of this repository ([examples/story-list](../examples/story-list)) switches with `?region=<id>&lang=<language>`.
+The optional listing index has `format: "ournotes.stories/1"` and a `stories` array. The player loads the manifest
+selected from that index. Entries include `id`, `advId`, `manifest`, `playbackMode`, localized `titles`, `language`,
+`languages`, and grouping information. A site can offer the same episode for several `regions`.
 
 ### Story facts
 
-The manifest's `story` object and every stories.json entry carry these facts (the player does not interpret them; a
-page gets them as `info.story`):
-
-| Key | Type | Meaning |
-|---|---|---|
-| `advId` | integer | The episode id. |
-| `asset`, `sheetName` | string | The episode asset and the sheet name of its `MasterAdv` row (`_advEpisodeAsset`, `_sheetName`). |
-| `playbackMode` | `0` \| `1` | `AdvPlaybackMode`: 0 Normal (the story draws its own stage), 1 Overlay (the game plays the episode in its simple ADV player, `SimpleAdvPlayer`, over the screen that opened it). |
-| `titles` | object | The episode title per language (`{ "<language>": "…" }`, the languages whose text is not empty). |
-| `groups` | object[] | Where the game lists the episode (below); empty when no story table names it. |
-| `commands` | string[] | The command names the player runs for the episode, sorted: the rows of the episode without `IgnoreData`, and the initialize and finalize rows of the player settings. |
-| `commandCount` | integer | Number of rows of the episode. |
-| `language` | string | The manifest's default language (below). |
-| `languages` | string[] | The languages of the manifest's language groups. |
-
-A group comes from one row of the game's story tables that names the episode (`_advId`), in this order:
-`MasterStoryEpisode` (kind `chapter`), `MasterStoryFriendshipEpisode` (`friendship`),
-`MasterStoryHomeSpotTapTalkEpisode` (`spotTalk`), `MasterStoryLiveResultEpisode` (`liveResult`), `MasterHomeSpot`
-(`spot`: the spot's own episode); rows of one table by id.
-
-| Key | Type | Meaning |
-|---|---|---|
-| `kind` | string | `chapter`, `friendship`, `spotTalk`, `liveResult` or `spot`. |
-| `id` | integer | The row's id in its table. |
-| `episodeNumber` | integer | Optional (`chapter`, `friendship`): the episode's number in its chapter or friendship story. |
-| `chapter` | object | Optional (`chapter`): `id` (`MasterStoryChapter` id), `names` (per language), `bandId` (0: none), `special` (`_isSpecialStory`). |
-| `characters` | object[] | The characters the row names (`chapter`: its character when it has one; `friendship`: the two characters of the friendship; `spotTalk`: the character; `liveResult`: the characters; `spot`: none), each `{ id, names }` with `id` the `MasterCharacter` id. |
-| `spot` | object | Optional (`spotTalk`, `spot`): `id` (`MasterHomeSpot` id), `names` (per language). |
-
-`names` objects hold the languages with a non-empty text.
+`groups` describes chapter, friendship, home spot and other listing groups. `commands` and `commandCount` describe
+the episode. A listing can expose download sizes and audio/font choices for its own UI; those are presentation
+metadata. Product loading follows `story.json.parts` and the file entries of the referenced manifests.
 
 ## Story manifest
 
-`stories/<advId>.json`, or `stories/<region>/<advId>.json` on a site of several regions
-([schema](../schema/story-manifest.schema.json)), lists the logical files of one story, where their bytes are, and
-the Live2D models the story uses.
+A manifest has the shared product fields:
 
 ```json
 {
-  "format": "ournotes.story-manifest/2",
-  "advId": 10462,
+  "schema": "nnnotes.product/1",
+  "product": "story",
+  "subject": "7",
   "root": "../",
-  "story": { "advId": 10462, "titles": { "…": "…" }, "commands": ["…"], "…": "…" },
-  "language": "en",
-  "audio": true,
-  "audioFormat": "aac",
-  "fonts": "open",
-  "requires": { "commands": ["Bgm", "Character", "…"], "cubismCore": true, "motionSync": true },
+  "language": "ja",
   "files": {
-    "story.json": { "asset": "assets/2f0c…91aa.json.gz", "size": 1155, "stored": 402 },
-    "scene.json": { "parts": [["player", "assets/b1d2…77e0.json.gz", 36212, 3810], "…"], "size": 171904 },
-    "…": "…"
+    "story.json": { "asset": "assets/<sha256>.json", "size": 123 },
+    "episode.json": { "asset": "assets/<sha256>.json", "size": 456 }
   },
-  "models": { "adv_live2d_rana_003_casual_spring_01": "models/adv_live2d_rana_003_casual_spring_01.json" },
-  "languages": {
-    "en": { "files": { "ui/ui.json": { "parts": ["…"], "size": 68113 },
-                       "ui/fonts.json": { "asset": "assets/…", "size": 52011 },
-                       "ui/fonts/font_Noto Sans CJK JP Regular SDF_0.png": { "asset": "assets/…", "size": 88120 },
-                       "ui/languages.json": { "asset": "assets/…", "size": 402 } } },
-    "…": "…"
-  }
+  "objects": {}
 }
 ```
 
-| Key | Type | Read by the player | Meaning |
-|---|---|---|---|
-| `format` | `"ournotes.story-manifest/2"` | yes | Version of this document; the player refuses other values. |
-| `advId` | integer | no | The episode id. |
-| `root` | string | yes | The site root relative to the manifest, `"../"` for `stories/<advId>.json`, `"../../"` for `stories/<region>/<advId>.json`. |
-| `story` | object | no | The [story facts](#story-facts), handed to the page as they are. |
-| `regions` | string[] | no | Optional. The regions this manifest serves. |
-| `language` | string | yes | The default language: the language the player loads when the page names none. One of the keys of `languages`. |
-| `audio` | boolean | yes | `false`: the story has no sound files (`story.json` `audio` is empty); the player plays it without its sounds (videos keep their own sound track). |
-| `audioFormat` | `"aac"` \| `"flac"` \| `null` | no | Format of every waveform file: AAC-LC in an MP4 container (`.m4a`) or FLAC; `null` without audio. |
-| `fonts` | `"open"` \| `"game"` | no | Where the glyphs of the [font assets](#fonts-uifontsjson) come from: font files of the producer's choice (`open`) or the game's own font assets (`game`). The format is the same; the player does not distinguish them. |
-| `requires` | object | yes | What the player needs to play the story: `commands` (equal to the facts' `commands`; a player that lacks one of them refuses the story before loading its files, naming them), `cubismCore` (`true`: the page must provide Live2D Cubism Core), `motionSync` (`true`: a Talk row maps a voice onto a character's lip sync, which needs Live2D's MotionSync Core with voices on). |
-| `files` | object | yes | The common files: logical path → [file entry](data-format.md#file-entries). None of them is under `live2d/`. |
-| `models` | object | yes | Model id → the path of its [model manifest](data-format.md#model-manifest) relative to the site root (`models/<id>.json`), keys sorted: the models of the story's Character rows (the ids of `story.json` `models`). |
-| `host` | object | no | Optional. An Overlay episode (`playbackMode` 1) with open fonts: the screen the game plays it over and the simple talk window ([story-simple.md](story-simple.md)): `kind` (`home`: a home spot talk; `afterlive`: the reward phase of a live result), `doc` (`host/host.json`), `ui` (`ui/simple/ui.json`). The player finds these files by path. Absent for a Normal episode and for an Overlay episode with game fonts, which then has no host data and no simple talk window (the simple player refuses it). |
-| `languages` | object | yes | Language → `{ files }`: the files of that language (below). At least one language. |
-
-File entries are exactly those of a chart manifest ([File entries](data-format.md#file-entries)): whole files
-`{ asset, size }`, encoded whole files `{ asset, size, stored }` and split JSON objects `{ parts, size }`, with the
-same rules (paths relative with `/`, `.json` and `.glsl` are UTF-8 text, encoded assets decoded, every size checked).
-The producer stores `scene.json` and `ui/ui.json` split per top-level key whatever their size, so the parts that
-stories and languages share are stored once; other JSON files are split as in the chart sites (above 512 KiB).
+The asset names above are placeholders. `subject` is the decimal episode id; authored stories can use `0`.
+`language` is optional. The public player chooses Japanese when offered, then the first available language, if
+neither its options nor the manifest specifies a language. `loadStoryStore` needs an explicit `lang` when the
+manifest has no default.
 
 ### Language groups
 
-`languages.<language>.files` holds the files whose contents differ between the languages of the story: in the current
-data `ui/ui.json` (the localized text records and line spacing), `ui/fonts.json` and its glyph pages `ui/fonts/*.png`,
-`ui/languages.json` and, with a `host`, `ui/simple/ui.json`, `ui/simple/fonts.json` and its pages
-`ui/simple/fonts/*.png`. A file whose bytes are the same in every language of the manifest is a common file instead;
-the fonts documents and glyph pages are always language files. Rules:
-
-- The paths of a language group and of `files` are disjoint. A player builds its file set from `files` and one group,
-  so a path that only some groups list (a glyph page named after its font) is never left over from another language.
-- A language group lists `ui/fonts.json`, `ui/languages.json` and every page that `ui/fonts.json` names; with a
-  `host`, also `ui/simple/fonts.json` and every page it names.
-- `language` is one of the keys of `languages`.
+`parts.ui`, `parts.fonts` and, for simple stories, `parts.simpleui` map the same language codes to product manifests.
+The loader selects one entry from each map. Codes are `ja`, `en`, `zh-Hant`, `zh-Hans` and `ko`. A partial export can
+retain paths for other languages; those languages need their products before they can be loaded.
 
 ## Loading a story
 
-A player plays a story from one language at a time. Its file set is the union of
+```js
+import { loadStoryStore, StorySession } from "ournotes-player/story";
 
-- `files`,
-- `languages[<language>].files`,
-- for every model of `models`, the `files` of its model manifest under `live2d/<id>/` (the model's `model.json` is
-  `live2d/<id>/model.json`),
+const assets = await loadStoryStore("https://example.test/stories/7.json", { lang: "ja" });
+const session = await StorySession.create(gl, assets, { autoplay: true });
+```
 
-and its object table the union of the `objects` of the model manifests: an object several models use is one object,
-listed alike in each (a store refuses manifests that differ on it).
+`fetchStoryManifest` fetches the product index and episode and checks the command set before media is downloaded.
+Its result can be passed to `loadStoryStore` as the `manifest` option. Downloads shared by products are reused;
+compatible object roles merge, and conflicting roles or product identities are errors.
 
-The logical paths are the same in every language, so the reader code does not change with the language. The model
-manifests are fetched together once the story manifest is read; their paths, like the asset paths, are relative to the
-site root (`root`). Loading with the chart loader works on that union: `AssetStore.fromManifest` reads the `files` and
-`objects` of the manifest it fetches, so a story loader passes it the manifest with both replaced by the unions (for
-example through its `fetch` option), or fetches the entries itself; the entry forms and checks are the same. A
-language switch loads the other language's group and keeps the common files and the models.
+Within the store, a product's own files are under its manifest path without `.json`: the files of
+`storyfonts/7_ja.json` are under `storyfonts/7_ja/`. The story's own files are under `stories/<advId>/`.
+Object files are accessed by id and role. The internal `StoryData` view resolves these paths for sessions.
 
-Every listed file is fetched before the story starts. A manifest lists the files the player's data (this document)
-names: shader directories keep only the GLES3 programs (GLSL ES 3.00) of the shaders they list; SPIR-V containers,
-GLSL ES 3.10 programs and the `streams.json` of the sound directories are left out.
+The Node `openStory` helper accepts a product manifest path or a layout containing exactly one manifest under
+`stories/`. When several stories exist, pass the chosen manifest explicitly.
 
 ## Logical files
 
-| Logical file | Content | Group |
+| Product | Document | Contents |
 |---|---|---|
-| `story.json` | Index: the paths of the files below. | common |
-| `episode.json` | The episode: command rows, texts, sounds, cue sheets, videos, master data row, title. | common |
-| `scene.json` | Player graphics, cameras, ADV fields, volumes, player settings, stages. | common |
-| `shaders/shaders.json`, `shaders/…` | Shaders of the scene, the stages and the media files ([Shaders](data-format.md#shaders)). | common |
-| `textures/*.png` | Textures of the scene and the media files ([Textures](data-format.md#textures)); paths relative to the story root. | common |
-| `live2d/<id>/model.json` | The Live2D models ([Live2D models](#live2d-models)): the `model.json` of each model manifest; their objects are in the object table. | model manifests |
-| `audio/<sheet>/cues.json`, `audio/<sheet>/<cue>.m4a` or `.flac` | Sounds per cue sheet ([Sounds](#sounds)). | common |
-| `ui/ui.json` | The story UI: front canvas nodes, sprites, materials, clips, controllers, transitions, text records ([Story UI](#story-ui-uiuijson)). | language (common when equal) |
-| `ui/textures/*.png`, `ui/shaders/…` | Packed UI textures and the UI shaders, including the TextMeshPro distance-field shader. | common |
-| `ui/fonts.json`, `ui/fonts/*.png` | TextMeshPro font assets, text materials and text bindings of the language ([Fonts](#fonts-uifontsjson)). | language |
-| `ui/languages.json` | The language settings ([Language](#language-uilanguagesjson)). | language |
-| `frames.json`, `effects.json`, `posteffects.json`, `stills.json`, `talkwindows.json`, `chat.json` | Media of the episode, each only when the episode uses it ([Media files](#media-files)). | common |
-| `videos/videos.json`, `videos/*.webm` | Movie and Clip videos (VP9 + Opus in WebM). | common |
-| `crilips/crilips.json`, `crilips/crilips.bin` | The CRI Lips analysis data (descriptor and float32 weights, [crilips.md](crilips.md#data-section-for-the-story-data-format)), only when a voice of the episode reaches the analysis. | common |
-| `host/host.json`, `host/ui/ui.json`, `host/spot/…`, `host/shaders/…` | With a `host`: the host screen (`ournotes.story-host/1`, [story-simple.md](story-simple.md#data)); the home spot's files under `host/spot/`. | common |
-| `ui/simple/ui.json`, `ui/simple/fonts.json`, `ui/simple/fonts/*.png`, `ui/simple/shaders/…` | With a `host`: the simple talk window in the story UI record format, its fonts and glyph pages in the format of `ui/fonts.json` and its text shader (paths relative to `ui/simple/`). | language (`ui.json` and the shaders common when equal) |
-
-The directory names are fixed: `ui/fonts.json` and `ui/languages.json` are found by path, the UI's texture and
-shader paths are relative to `ui/`, the scene's and the media files' texture paths to the story root.
+| `story` | `story.json`, `episode.json` | Episode and part graph |
+| `story.scene` | `scene.json` | Shared scene, camera, fields, volumes and graphics settings |
+| `story.asset` | `asset.json` | Media roots, animation bindings and shaders |
+| `story.ui` | `ui.json` | Story UI prefabs and language settings |
+| `story.fonts` | `fonts.json` | Font bindings, glyph pages and text material shaders |
+| `story.simpleui` | `ui.json` | Simple talk window and system message prefabs |
+| `story.host` | `host.json` | Home or live-result screen references |
+| `story.sound` | `cues.json` | CRI cues and waveform files |
+| `story.video` | `video.json` | Movie metadata and WebM file |
+| `story.chat` | `chat.json` | Shared chat text and sound tables |
+| `story.crilips` | `crilips.json`, `crilips.bin` | CRI Lips descriptor and weights |
+| `live2d.model` | `model.json` | Character model and its object references |
+| `room.gltf` | `room.json`, `room.glb` | Room geometry, node order and material ids |
+| `spot.files` | `spot.json` | Home situation and Spine files |
 
 ## story.json
 
-([schema](../schema/story.schema.json)) The index of the story directory.
+The index has `format: 1`, `advId`, `episode: "episode.json"`, `parts`, `chats` and `effects`.
 
-```json
-{ "advId": 10462, "episode": "episode.json", "scene": "scene.json", "ui": "ui/ui.json",
-  "models": { "Character/Live2D/003_adv/…/model/…": "adv_live2d_rana_003_casual_spring_01" },
-  "audio": { "sound_bgm_adv_…": "audio/sound_bgm_adv_…" },
-  "frames": null, "effects": null, "postEffects": null, "stills": null, "talkWindows": null, "chat": null,
-  "videos": null, "crilips": null }
-```
+- `parts.scene`, optional `parts.chat` and optional `parts.crilips` name shared products.
+- `parts.assets` maps addresses such as `Adv/Stage/<name>` to media products.
+- `parts.models` maps `Character/Live2D/<group>/<name>/model/<name>` to model products.
+- `parts.sounds` maps cue-sheet names to sound products, and `parts.videos` maps `Cri/Video/<name>` to videos.
+- `parts.ui`, `parts.fonts` and optional `parts.simpleui` select language products.
+- `parts.host`, `parts.rooms` and `parts.spots` identify the simple story's host dependencies.
 
-| Key | Meaning |
-|---|---|
-| `advId` | The episode id. |
-| `episode`, `scene`, `ui` | Paths of [episode.json](#episodejson), [scene.json](#scenejson) and [ui/ui.json](#story-ui-uiuijson). |
-| `models` | Model key (the address the episode's Character rows name, `Character/Live2D/<group>/<name>/model/<name>`) → the model id (its `model.json` under `live2d/<id>/`, [Live2D models](#live2d-models)). |
-| `modelsDir` | Only in a story directory (a story's logical files as files on disk, outside a site): the directory holding its models, `<modelsDir>/<id>/model.json` and the files it names, relative to the story directory with `/`. A reader of the directory maps `live2d/<id>/…` there. Not in a site. |
-| `audio` | Cue sheet name → its directory. Empty when the manifest's `audio` is `false`. |
-| `frames`, `effects`, `postEffects`, `stills`, `talkWindows`, `chat` | Path of the media file of that kind, `null` when the episode does not use it. |
-| `videos` | `videos/videos.json`, or `null` when the episode has no video. |
-| `crilips` | `{ "descriptor": "crilips/crilips.json", "data": "crilips/crilips.bin" }`: the CRI Lips analysis data, present when a voice of the episode reaches the analysis (a lip-synced voice while a model has no MotionSync controller, or a voice that other speakers follow); else `null`. Absent in sites built before it; the player then gives those speakers no analysis (`lipSyncMissing` `"CRI Lips analysis"`). |
+`chats` holds the episode's master chat rows. `effects` maps command target names to effect addresses.
+Optional `host` contains the episode's host choice, including home talk kind, tap character, spot and localized title.
+The reusable host product contains the screen resources and scene references.
 
 ## episode.json
 
-([schema](../schema/episode.schema.json)) The episode after the game's episode asset and its text, sound, cue sheet and
-video tables.
+The episode has command rows (`commands`, `commandCount`), localized `text`, `sounds`, `cuesheets`, `videos`, resource
+addresses, a `master` row and localized `title`. Each command has `i`, `cmd`, `raw` and its serialized non-default
+parameters. Text fields are `japanese`, `english`, `traditionalChinese`, `simplifiedChinese` and `korean`.
 
-| Key | Meaning |
-|---|---|
-| `advId`, `asset` | The episode id and its episode asset name. |
-| `commands` | The rows in order: `i` (the row's `Index`), `cmd` (the `AdvCommand` name; `Cmd<n>` for a value without a name), `raw` (the `AdvCommand` value), and every field of the row whose value is not empty, zero or false, under its serialized name: `TargetName`, `TargetAssetName`, `TargetAssetIndex`, `PositionType`, `CameraDistance`, `Duration`, `DelaySeconds`, `IsNoWait`, `IgnoreData`, `IgnoreLipSync` (flags as 0 / 1), `Parameter1` … `Parameter4`, `TargetTextIDs`, `TargetTextColors`, `TargetStatus`, `AdvTextID`, `VoiceIDs`, `MotionName`, `MotionFadeIn`, `MotionWait`, `ExpressionName`, `BgmID`, `SeID`, `Key`, `VideoID`, `TargetChatID`, …. A missing field has its default (empty, 0, false). Added: `lines` (the text of `AdvTextID` per text field, below) and `voiceCues` (the cue names of `VoiceIDs`). |
-| `commandCount` | Number of rows. |
-| `text` | Text id → text per text field. |
-| `sounds` | Sound id → the episode's sound row (`_soundCueSheetID`, `_cueName`, …). |
-| `cuesheets` | Cue sheet id → the episode's cue sheet row (`_cueSheetName`, …). |
-| `videos` | Video id → the episode's video row (`_assetName`, …). |
-| `resources` | The episode's asset closure: `[{ kind, address, present }]`. |
-| `master` | The `MasterAdv` row: `_id`, `_sheetName`, `_advEpisodeAsset`, `_titleTextId`, `_rubyTitleTextId`, `_playbackMode`. |
-| `title` | The title text per text field, or `null`. |
-
-Text fields are the columns of the game's text tables without the underscore: `japanese` (ja), `english` (en),
-`traditionalChinese` (zh-Hant), `simplifiedChinese` (zh-Hans), `korean` (ko); a language's UI data names its field
-(`ui/languages.json` `field`). Ids of the id maps are decimal strings or the game's text ids.
+The player combines these commands with the initialize/finalize commands of `AdvPlayerSettings`. Overlay episodes
+use the SimpleAdvPlayer command set. Playback behavior is described in [story.md](story.md) and
+[story-simple.md](story-simple.md).
 
 ## scene.json
 
-The story scene after Unity serialization (the same node, component, material and texture conventions as the live
-scene, [Live scene](data-format.md#live-scene-livescenescenejson)). Keys read:
-
-| Key | Content |
-|---|---|
-| `player` | Player graphics: the quality levels, URP assets, renderers and renderer features. |
-| `cameraManager` | `{ nodes }`: the camera hierarchy (`CameraManager/MainCamera`). |
-| `advScene`, `characterField`, `backgroundField`, `globalVolume` | The ADV scene objects: node lists with their components (fields, volumes and profiles inline). |
-| `settings.playerSettings` | `AdvPlayerSettings`: `_initializeEpisodes`, `_finalizeEpisodes` (rows with `Command` values, run before and after the episode), `_focusDataSettingsMap`, `_defaultFocusDataSettingsKey`, `_defaultPanV2FocusSlideRate`, `_defaultTransitionAssetAddress`, `_waitTalkTextUnitTime`, `_minTalkDisplayTime`, `_waitAfterVoiceTime`, `_targetNameSplitKey`, the `_allow*` flags, wait and shake values. |
-| `settings.masterIdSettings` | `AdvMasterIdSettings`: `_unknownCharacterNameTextId`, `_splitCharacterNameTextId`. |
-| `stages` | Stage key (the address after `Adv/Stage/`) → the stage prefab (node list) of every stage the episode uses. |
-| `postTextures` | Renderer name → post-processing textures (`filmGrainTex`, …) as texture descriptors. |
-| `shaders.cameraRenderers` | The shader names each camera renderer draws with. |
+The scene has `format: 1`. `scene` names scene root GameObjects; `renderSettings` names the RenderSettings object.
+`prefabs` names `cameraManager`, `characterField`, `backgroundField` and `globalVolume`. `settings` names the player
+and master-id MonoBehaviours. `graphics` names GraphicsSettings, PlayerSettings and QualitySettings objects.
 
-Other keys are not read.
+`bindings` maps prefab id → Animator node path → clip id → ordered `{path, attribute}` names. A null path leaves
+that binding unbound. `shaders` maps Unity shader names to object ids; each material uses its own shader reference.
+Several objects may legitimately have the same Unity name.
 
 ## Sounds
 
-`audio/<sheet>/cues.json` per cue sheet the episode's cue sheet table names: cue name → the cue's first waveform.
+Each `cues.json` maps cue names to `file`, `sampleRate`, `samples`, `channels`, optional loop points and `categories`.
+The waveform path is relative to that sound product. AAC files use `.m4a` and can include `encoderDelay`; FLAC files
+use `.flac`. Loop bounds are measured in source samples and must fit within the waveform.
 
-```json
-{ "adv_voice_…_001": { "file": "adv_voice_…_001.m4a", "sampleRate": 48000, "channels": 1, "samples": 120960,
-                       "encoderDelay": 1024 },
-  "sound_bgm_adv_…": { "file": "sound_bgm_adv_….m4a", "sampleRate": 48000, "channels": 2, "samples": 4608000,
-                       "loopStart": 96000, "loopEnd": 4608000, "encoderDelay": 1024 } }
-```
+The episode's sound row resolves its cue sheet through `_soundCueSheetID` and its cue through `_cueName`. CRI cue
+categories choose the volume bus; the sound row's category controls BGM crossfade and stop behavior.
 
-| Key | Meaning |
-|---|---|
-| `file` | The waveform file, relative to the sheet's directory: AAC in MP4 (`.m4a`) or FLAC, as the manifest's `audioFormat`. |
-| `sampleRate`, `channels`, `samples` | As in a live's [sound layers](data-format.md#sounds-soundsjson-musicjson): `samples` counts frames at `sampleRate`, without encoder padding. |
-| `loopStart`, `loopEnd` | Optional: loop points in sample frames. |
-| `encoderDelay` | Optional, AAC only: the priming samples at the start of the stream, handled as for a live's layers. |
+## Live2D models
 
-A sound id of a row (`BgmID`, `SeID`, `VoiceIDs`) resolves through `episode.json`: `sounds[id]` gives the cue name (`_cueName`) and
-the cue sheet id (`_soundCueSheetID`), `cuesheets[<cue sheet id>]._cueSheetName` the directory `story.json` `audio` names. Lip sync reads the
-decoded PCM of the voice file; with AAC data its samples differ from the game's in the last bits (a lossy codec).
+Story models are [model products](data-format.md#live2d-models) with `model.json` format 3. A model's prefab, clips,
+materials, shader programs, textures and moc bytes resolve through the shared object table. The model validator
+checks its standalone and story lighting variants.
 
-## Live2D models
+## Story UI
 
-Each model is a model of the site ([Live2D models](data-format.md#live2d-models)): its manifest `models/<id>.json`,
-listed in `models.json`, whose `model.json` the player loads as `live2d/<id>/model.json` and whose objects it adds to
-the store's object table. The story player reads them as the model viewer does: `model.json` names the prefab, the
-moc, the shaders and the Cubism mask materials by object id; a character draws with its model's own shaders and with
-the mask materials of its `model.json` `resources`. The story renderer adds `_ADDITIONAL_LIGHTS_VERTEX` to every
-character draw at quality 4, so each model's shaders hold, for every keyword set its drawables use, the program of the
-set and of the set with `_ADDITIONAL_LIGHTS_VERTEX` ([Model shaders](data-format.md#model-shaders)). A model the
-stories share is one manifest, and an object the models share (a mask material, a shader) is one object. A
-character's MotionSync controller comes from its prefab.
-
-## Story UI (`ui/ui.json`)
-
-The parts of the game's ADV widget (`UIAdvWidget`) the story draws: the front canvas (talk window, speaker plate,
-episode title, location caption, rule transition cover, curtains, flash, subtitles caption, next indicator, menu
-entry button, menu panel and video buttons, backlog, choices, the next and cancel-full-screen tap areas), the screen
-canvases of videos, stills and frames with the screen image of the video-and-still camera, and the letterbox bands;
-the phone of the chat rows (`UIAdvChatWidget`) and the text records of the episode's chat windows; the dialogs of the
-ADV screen. Keys read:
-
-| Key | Content |
-|---|---|
-| `nodes` | The RectTransform hierarchy (node order: every parent before its children): `path`, `name`, `active`, `localPosition`, `localRotation`, `localScale`, `rect`, and the uGUI parts the story draws: `canvas`, `canvasScaler`, `canvasGroup`, `image`, `rawImage`, `gradient`, `layoutGroup`, `contentSizeFitter`, `layoutElement`, `safeAreaEdgeAnchor`, `animator`, `tweenSequence`, `animationTrigger`, `talkWindow`, `buttonImageState`, `outline`, `ruleTransition`, `localizeText`, the view records and `behaviours` (below); a text node has `textStyle` (below). A node whose parent is not listed is a child of the widget root. The talk windows are children of `UIAdvWidget/FrontCanvas/UISafeArea/UIContainer/TalkView`, each with its prefab's nodes and a `talkWindow` record on its root (`_typingDelay`, `_safeAreaTalkBackgroundExpansionFactor`, `_useBackdropFilter`, `_backdropFilterColor`, `_talkTextColor`, `_talkTextOutlineColor`): `UIDefaultTalkWindow` first, then by name every other window the episode's `TalkWindow` rows attach (such as `UICenterTalkWindow`). When one of them has `_useBackdropFilter` set, the nodes also hold the front canvas' `CenterTalkBackdrop` (`canvasGroup` and `image`: the backdrop behind that window's talk). |
-| `frontCanvasOrder` | Sibling order of the front canvas' children. |
-| `widget` | `canvasSortOrder` (`UIWidget._canvasSortOrder`) and `canvases`: the widget's canvases in `UIWidget._canvases` order, each `{ path, sortingOrder }` (the canvas' `m_SortingOrder`; `UIWidget.TrueCanvasSortOrder` is the first one's, 99999 without canvases). The paths may name canvases that are not in `nodes`. |
-| `videoAndStillCamera` | The camera the video and still canvases render with (`UIAdvWidget._videoAndStillCamera`): `path` (its node, not in `nodes`), `active`, `camera` (`m_ClearFlags`, `m_BackGroundColor`, `m_NormalizedViewPortRect`, `near clip plane`, `far clip plane`, `field of view`, `orthographic`, `orthographic size`, `m_Depth`, `m_CullingMask`, `m_HDR`, `m_AllowMSAA`) and `additionalCameraData` (URP: `m_RenderPostProcessing`, `m_VolumeLayerMask`, `m_RendererIndex`, antialiasing, shadow and texture options, `m_CameraType`, `m_VolumeFrameworkUpdateModeOption`, `m_Dithering`, `m_StopNaN`). |
-| `uiCamera` | The UI camera of the `UIManager` prefab (`UIManager._cameraController` → `UICameraController._uiCamera`, with its `_uiCameraData`), in the form of `videoAndStillCamera`. The frame canvas has no camera in the widget prefab; this camera renders it at run time, and the canvas particle graphics are baked with it. |
-| `videoAndStillScreenImage` | The node of the raw image that shows that camera's output (`UIAdvWidget._videoAndStillScreenImage`). |
-| `masterIdTexts` | The `AdvMasterIdSettings` texts of the dialogs in the language: `_skipVideoMessageTextId`, `_skipButtonTextId`, `_cancelButtonTextId` (the video skip dialog), `_skipMessageTextId`, `_continuousSkipMessageTextId`, `_backEpisodeListButtonTextId`, `_continueEpisodeButtonTextId` (the skip confirm dialog), `_interruptionTitleTextId`, `_interruptionMessageTextId`, `_interruptionButtonTextId` (the interruption dialog) → `{ id, text }` (the `MasterText` id and its text). |
-| `dialogs` | Dialog name → `{ key, nodes }`: the prefab of the dialog (`UIAdvSkipConfirmDialogWidget`, the skip confirm dialog; `UICommonDialogWidget`, the dialog `CommonDialogManager` opens) and its nodes as node records (paths start with the dialog name); text nodes have `textStyle`. |
-| `chatWidget` | `{ nodes }`: the phone the chat windows attach to (`UIAdvChatWidget`), as node records: `ChatCanvas` (`canvas`, `canvasScaler`), `ChatCanvas/AdvChatView` (rect and the `chatView` record) and its `Target` (rect, `canvasGroup`). Paths start with `UIAdvChatWidget/`. |
-| `chatTexts` | Optional, an episode with chat windows: window name (the prefab after `Adv/Chat/Prefabs/`, as `chat.json` `windows`) → text node path (as in that window's node list) → `{ textStyle, localizeText }`: the text record of each TextMeshPro text of the window in the language (below; a localized text with the font and material `LocalizeText` gives it, its `fontRole` the slot of the Japanese lookup table, `font2` and up for the additional fonts) and the node's `LocalizeText` flags (`null` without one). |
-| `chatStatusTexts` | Optional, with chat windows and the master data: `MasterText` id → its text in the language, for the incoming call and lock screen status keys of the windows (`AdvChatWindow._incomingCallStatusTextKey`, `_lockScreenStatusTextKey`). |
-| `sprites`, `letterBoxSprite` | Sprite name → sprite descriptor on a packed texture; the letterbox band sprite's name. |
-| `textures` | Packed texture name → texture descriptor (paths relative to `ui/`). |
-| `materials`, `materialKeywords` | The UI materials (the rule transition's, `Default UI Material`, the materials the drawn images name, such as the video mask's) and the GLES3 keyword set of each. |
-| `blur` | Optional, with a talk window whose `talkWindow._useBackdropFilter` is set: the UI blur the game runs while that window's talk area is shown (`UIManager.UseBlur`: everything drawn before the front canvas is blurred). `renderer` and `active`, then the renderer feature's pass settings `iterations`, `offset`, `downsample` and `blendRateMax`, and `shader`, the Dual Kawase blur shader (in `shaders`). |
-| `clips`, `controllers` | Animation clips and animator controllers of the indicators, title and location animations. |
-| `transitions` | Transition address → `RuleTransitionSettings` with its rule texture. |
-| `playerSettings` | `_defaultTransitionAssetAddress`, `_waitAfterVoiceTime`, `_waitTalkTextUnitTime`, `_minTalkDisplayTime`, `_isAdvViewportFollowOnResolutionChanged`. |
-| `dotween` | The game's DOTween defaults. |
-| `shaders` | `{ index: "shaders/shaders.json", names }`: the UI shader directory, relative to `ui/`. |
-| `language` | `mode` (`LanguageMode`), `field` (the text field), `lineSpacing` (the line spacing localized texts get). |
-| `textStyle` | `language`, `units`, `roles`: the line metrics per font role of the game's fonts. The layout uses the font assets of `ui/fonts.json`; with open fonts it takes the line height, ascent and descent of their role from here ([Fonts](#fonts-uifontsjson)). |
-
-Node records beyond the uGUI component fields:
-
-- `canvas`: `m_Enabled`, `m_RenderMode`, `m_SortingOrder`, `m_OverrideSorting`, `m_PixelPerfect`,
-  `m_VertexColorAlwaysGammaSpace`, `m_AdditionalShaderChannelsFlag`; a screen-space-camera canvas (`m_RenderMode` 1)
-  also `m_PlaneDistance` and, when it has a camera, `camera` (the camera's node path, `videoAndStillCamera` `path`).
-- `canvasScaler`: the `CanvasScaler` fields (`m_UiScaleMode`, `m_ReferenceResolution`, `m_ScreenMatchMode`,
-  `m_MatchWidthOrHeight`, `m_ReferencePixelsPerUnit`, `m_ScaleFactor`, `m_Enabled`); for the game's
-  `ClampedCanvasScaler` also `class` and `_maxAspectThreshold` (the aspect ratio past which the scale stops growing).
-- `rawImage`: `m_Enabled`, `m_Color`, `m_UVRect`, `m_RaycastTarget`, `m_Maskable`, `texture` (null: set at run
-  time), `material`.
-- `buttonImageState`: `normal` (the sprite of the normal state) and, for a button with a selected state, `selected`
-  and `target` (the node of the image whose sprite changes). A node with several `ButtonImageState` components has
-  them in `behaviours` instead.
-- `behaviours`: class → one record per component of that class on the node, in component order, for the game and
-  uGUI components that have no record of their own: `UIButton`, `ButtonActiveState`, `ButtonAnimationScale`,
-  `ButtonSound`, `ButtonImageState` (several on a node), `SimpleRaycastTarget`, `GraphicColorSynchronizer`,
-  `UIText`, `AspectRatioFitter`, `UIToggle`, `UIToggleGroup`, `UIToggleButtonFrame`, `UIDecoratedNormalButton`,
-  `UIDecoratedNormalButtonFrame`, `UIAddressableImage`, `UISafeArea`, `AdvViewportSafeArea`, `EnhancedScrollRect`,
-  `EnhancedScroller`, `ScrollRect`, `RectMask2D`, `Scrollbar`, `DOTweenAnimation`, `LocalizeSpriteEvent`,
-  `AdvTalkLogEntryView`, `AdvChoiceItem`, `DialogButtons`, `DialogAnimation`, `DialogSizeFitter` and the dialog
-  widgets. A record holds every serialized field of the component (without the object header): references as node
-  paths (a reference outside the exported nodes keeps its path), sprites as sprite names (each in `sprites`),
-  assets, materials and textures as names. `UIPictogram` records hold `m_Enabled`, `_key`, `_image`, `_setNativeSize`,
-  `catalog` and the catalog's `sprite` for the key (`null` when the catalog has none) with its `defaultSprite`.
-  Localized sprites (`LocalizeSpriteEvent`, the menu's per-language button sprites) are not resolved; their records
-  name the table entry.
-- `safeAreaEdgeAnchor`: `enabled` and `_left`, `_right`, `_top`, `_bottom` (`_target`, `_anchor`, `_offset`): the
-  node's edges anchored to the safe area or the screen (`UISafeAreaEdgeAnchor`).
-- View records, their serialized references as node paths: `videoView` (`AdvVideoView`: `_video`, `_maskArea`,
-  `_curtainCanvasGroup`, `_videoCanvasGroup`), `stillView` (`AdvStillView`: `_overlay`, `_background`, `_target`),
-  `frameView` (`AdvFrameView`), `flashView` (`AdvFlashView`: `_flash`), `subtitlesView` (`AdvSubtitlesView`:
-  `_subtitles`, `_subtitlesText`), `frontScreenView` (`AdvFrontScreenView`: `_nextButton`, `_nextIndicator`,
-  `_cancelFullScreenButton`, `_uiContainer`), `talkLogView` and `choiceView` (`AdvTalkLogView`, `AdvChoiceView`:
-  every serialized field, such as `_scroller`, `_entryViewOrigin`, `_fadeDuration`, `_choiceItems`,
-  `_animationIntervalIn`), `menuView` (`AdvMenuView`: `_menuButtonsParent`, `_menuEntryButton`,
-  `_skipButton`, `_autoButton`, `_fastForwardButton`, `_logButton`, `_continuousButton`, `_fullScreenButton`,
-  `_interruptionButton`, `_menuButtonsBackground`, `_canvasGroup`, `_skipVideoButton`, `_pauseVideoButton`,
-  `_subtitlesButton`, `_videoButtonParent`, `_videoFilterButton`, `_fastForwardButtonImage`; also the sprite names of
-  the fast-forward speeds `_fastForwardNormalSprite`, `_fastForwardOnePointFiveSprite`,
-  `_fastForwardOnePointSevenSprite`, `_fastForwardDoubleSprite`, in `sprites`, and `_fadeDuration`), `chatView`
-  (`AdvChatView`, in `chatWidget`: `_showEaseDuration`, `_hideEaseDuration`, `_showEase`, `_hideEase`,
-  `_scrollDuration`, `_typingDelay`, `_typingTextBoxMinHeight`, `_screenModeTransitionDuration`,
-  `_screenModeTransitionEase`, `_incomingCallPositionOffset`, `_windowParentRect`); each with `enabled`. A reference
-  may name a node that is not in `nodes`.
-
-A text node's `textStyle` is its TextMeshPro text record in plain values: `fontRole` (`primary` or `number`),
-`materialType`, `localized`, `textKey`, `text`, `richText`, `fontSize`, `autoSize`, `fontStyle`, `alignment`,
-`wrapping`, `overflow`, `margin`, `lineSpacing` (`serialized`, `applied`, `byLanguage`), spacing values, `color`,
-`colorMode`, and the look of its material in em (`face`, `outline`, `underlay`). The layout itself uses the serialized
-TextMeshPro fields and the bindings of `ui/fonts.json` `texts`.
-
-## Fonts (`ui/fonts.json`)
-
-([schema](../schema/story-fonts.schema.json)) The TextMeshPro data the story's texts are laid out and drawn with in one
-language: font assets holding exactly the characters the episode shows in that language, their glyph pages, the text
-materials and, per text node, the font asset and material it uses. The player lays text out with TextMeshPro's rules
-using these glyph metrics and draws it with the distance-field shader the material names (in `ui/shaders/`). The
-format is the same whether the glyphs were generated from a font file (`source` `open`) or taken from the game's font
-assets (`game`). With open fonts, a font asset that the texts of a font role use (the role's `fontAsset` in
-`ui/languages.json`, or the font asset of a text node of the UI, a dialog or a chat window whose `textStyle.fontRole`
-names the role) is laid out with the line height, ascent and descent of the game's font of that role (`ui.json`
-`textStyle.roles`) in place of its own face info's. Any other open asset named `<open font> (<game font asset>)` (a
-fallback, such as the Japanese font behind the untranslated Japanese labels of the Korean chat window) takes those of
-the game font asset it stands in for, where the player knows them (A-OTF-ShinGoPr6N, VibeMOPro, FZLTH_GB18030L2_R,
-Pretendard SemiBold). The language's line spacing is set for the game's fonts: English's -100 takes one em off the
-pitch of a font whose line height is 2 em, and would put the lines of a 1.448 em face 0.448 em apart.
+`ui.json` has `format: 1` and references the story `widget`, `chatWidget`, `uiManager`, `talkWindows`, `dialogs`,
+`letterbox`, animation `clips` and `controllers`. Native prefab components hold layout, graphics, text and behavior
+fields. `settings` identifies DOTween, TMP, localization and master-id settings.
 
-```json
-{ "format": "ournotes.story-fonts/1", "language": "en", "source": "open",
-  "fonts": { "Noto Sans CJK JP Regular SDF": { "faceInfo": { "m_PointSize": 40, "…": "…" }, "characters": { "…": "…" },
-                                              "glyphs": { "…": "…" }, "…": "…" } },
-  "textures": { "font_Noto Sans CJK JP Regular SDF_0": { "texture": "fonts/font_Noto Sans CJK JP Regular SDF_0.png",
-                                                         "width": 2048, "height": 312, "…": "…" } },
-  "materials": { "Noto Sans CJK JP Regular - OutlineAdvCommon": { "shader": { "shader": "TextMeshPro/Mobile/Distance Field" }, "…": "…" } },
-  "materialKeywords": { "Noto Sans CJK JP Regular - OutlineAdvCommon": ["OUTLINE_ON"] },
-  "texts": { "UIAdvWidget/…/TalkText": { "m_fontSize": 42, "…": "…",
-                                         "localized": { "fontAsset": "Noto Sans CJK JP Regular SDF",
-                                                        "material": "Noto Sans CJK JP Regular - OutlineAdvCommon",
-                                                        "lineSpacing": -100 } } },
-  "coverage": { "characters": 61, "missing": [] } }
-```
+`texts` maps TMP component ids to a resolved `localized` font/material record and a style summary. `language` and
+`textStyle` describe localization. The font product supplies the final font binding used to draw each text.
 
-| Key | Type | Meaning |
-|---|---|---|
-| `format` | `"ournotes.story-fonts/1"` | Version of this document. |
-| `language` | string | The language (`ja`, `en`, `zh-Hant`, `zh-Hans`, `ko`). |
-| `source` | `"open"` \| `"game"` | Where the glyphs come from (the manifest's `fonts`). |
-| `fonts` | object | Font asset name → [font asset](#font-assets). |
-| `textures` | object | Glyph page name → texture descriptor ([Texture descriptors](data-format.md#texture-descriptors)): `texture` (the PNG, relative to `ui/`, under `ui/fonts/`), `name`, `width`, `height`, `mipCount` (1), `settings`. |
-| `materials` | object | Material name → the TextMeshPro material in the inline material form of the scene files ([Node lists](data-format.md#node-lists)): `material`, `shader` (`{ shader: "TextMeshPro/Mobile/Distance Field" }` in the current data), `keywords`, `textures` (`_MainTex`: the glyph page it samples, `{ name, width, height, format }`), `floats` (`_GradientScale`, `_ScaleRatioA` … `_ScaleRatioC`, `_FaceDilate`, `_OutlineWidth`, `_OutlineSoftness`, `_UnderlayOffsetX`, `_UnderlayOffsetY`, `_UnderlayDilate`, `_UnderlaySoftness`, `_WeightNormal`, `_WeightBold`, `_TextureWidth`, `_TextureHeight`, …), `ints`, `colors` (`_FaceColor`, `_OutlineColor`, `_UnderlayColor`). The text materials of `texts` and the default material of every font asset. |
-| `materialKeywords` | object | Material name → the keywords of its GLES3 program (the material's keywords that the shader's GLES3 variants use). |
-| `texts` | object | Text node path (as in `ui/ui.json` `nodes`) → the node's text binding (below). Every text node of `ui/ui.json`. |
-| `dialogTexts` | object | Optional, open fonts: dialog name → text node path → text binding, one per text node of `ui/ui.json` `dialogs`. Game-font data has no dialog bindings. |
-| `chatTexts` | object | Optional, open fonts and an episode with chat windows: window name → text node path → text binding, one per text of `ui/ui.json` `chatTexts`. A text without `LocalizeText` keeps its serialized font asset, material and line spacing in `localized`. Game-font data has no chat bindings. |
-| `frameTexts` | object | Optional, open fonts and an episode whose frames have text nodes: frame name (a key of the story's `frames.json` `frames`) → text node path → text binding, one per node of the frame's prefab with a TextMeshPro text component (`TextMeshProUGUI`, `RubyTextMeshProUGUI`, `RubyEmojiTextMeshProUGUI`). A text without `LocalizeText` keeps its serialized font asset, material and line spacing in `localized`. Game-font data has no frame bindings. |
-| `spriteAssets` | object | Optional: sprite asset name → [sprite asset](#sprite-assets), present when the episode's texts draw sprites (the game's emoji sprite asset). |
-| `emojiSpriteAsset` | string | With `spriteAssets`: the sprite asset `LocalizeManager.EmojiSpriteAsset` is (a key of `spriteAssets`): the one a `UIText` gives its text, and the one `TmpTextHelper.CombineEmojiSequences` reads for a text without a sprite asset. |
-| `coverage` | object | `characters` (distinct characters shown), `missing` (as strings, not the characters a sprite draws: with game fonts the characters no font asset of the chain has, which TextMeshPro draws as its missing glyph (`missingGlyph`); with open fonts the characters the game's font assets have and no font file of the open chain has, which the player does not lay out: a text that shows one fails), `missingGlyph` (optional: the characters of the font assets' `missingGlyph`, as strings, ascending), with sprites `sprites` (`characters`: the sprite characters held, `missing`: the names of those without an image), and producer details. |
-| `tmpSettings` | object | Optional (game): the game's TMP Settings values (`m_missingGlyphCharacter`, …). |
-| `lineBreaking` | object | Optional: TextMeshPro's line breaking rules of the game's TMP Settings: `leading` and `following` (the text of its leading and following characters files, as stored) and `useModernHangulLineBreakingRules`. A layout that breaks a line next to a character of these sets needs it. |
-
-A text binding holds the text component's serialized TextMeshPro fields (`m_fontSize`, `m_fontSizeBase`,
-`m_fontStyle`, `m_fontWeight`, `m_HorizontalAlignment`, `m_VerticalAlignment`, `m_characterSpacing`,
-`m_wordSpacing`, `m_lineSpacing`, `m_paragraphSpacing`, `m_characterHorizontalScale`, `m_TextWrappingMode`,
-`m_overflowMode`, `m_enableAutoSizing`, `m_fontSizeMin`, `m_fontSizeMax`, `m_enableKerning`, `m_ActiveFontFeatures`,
-`m_enableExtraPadding`, `m_isRichText`, `m_parseCtrlCharacters`, `m_isOrthographic`, `m_overrideHtmlColors`,
-`m_margin`, `m_fontColor`, `m_Color`, `m_colorMode`, `m_enableVertexGradient`, `m_TextStyleHashCode`,
-`m_useMaxVisibleDescender`, `m_horizontalMapping`, `m_verticalMapping`, `m_charWidthMaxAdj`, `m_lineSpacingMax`,
-`m_isRightToLeft`, `m_text`, and `m_monospaceDistEm` for the emoji text class), `class` (`TextMeshProUGUI`,
-`RubyTextMeshProUGUI`, `RubyEmojiTextMeshProUGUI`),
-`enabled`, `fontAsset` and `material` (the serialized font asset and material names), `localized`: what the text
-uses in this language after `LocalizeText` — `fontAsset` (a key of `fonts`), `material` (a key of `materials`) and
-`lineSpacing` (the line spacing it gets) — and, optionally, the ruby settings: `ruby` for a ruby text class
-(`RubyTextMeshProUGUI`, `RubyEmojiTextMeshProUGUI`: the serialized `_rubyVerticalOffset`, `_rubyScale`,
-`_rubyLineHeight`, `_rubyShowType`, `_rubyMargin`) and `uiRubyText` for a node with a `UIRubyText` component
-(`_rubyMarginTop`); `localizeKoreanAdjust` for a node with a `LocalizeKoreanAdjust` component (`_koreanFontStyle`: in
-Korean, 1 clears and 2 sets the bold style of `m_fontStyle`; `m_Enabled`). A text a `UIText` (or `UIRubyText`) drives
-has `spriteAsset` (a key of `spriteAssets`: `UIText.Awake` gives the text `LocalizeManager.EmojiSpriteAsset`) and its
-serialized `m_tintAllSprites`, when `spriteAssets` is present; any other text has no sprite asset.
+`story.simpleui` uses `nnnotes.story-simple-ui/1` and references `talkWindow`, `systemMessage` and `uiManager` with
+the same settings, language, text and binding contracts.
 
-### Font assets
+## Fonts
 
-A font asset is a TextMeshPro font asset reduced to the characters the episode shows:
+`fonts.json` has `format: "nnnotes.story-fonts/1"`, a `language`, `source` (`open` or `game`), `fonts`, `textures`,
+`materials`, `materialKeywords`, `shaders`, `texts`, `sprites`, `coverage` and `lineBreaking`.
 
-| Key | Meaning |
-|---|---|
-| `faceInfo` | TMP `m_FaceInfo`: `m_FamilyName`, `m_StyleName`, `m_FaceIndex`, `m_PointSize` (the sampling point size, px per em), `m_Scale`, `m_UnitsPerEM`, `m_LineHeight`, `m_AscentLine`, `m_CapLine`, `m_MeanLine`, `m_Baseline`, `m_DescentLine`, `m_SuperscriptOffset`, `m_SuperscriptSize`, `m_SubscriptOffset`, `m_SubscriptSize`, `m_UnderlineOffset`, `m_UnderlineThickness`, `m_StrikethroughOffset`, `m_StrikethroughThickness`, `m_TabWidth` (lengths in px at `m_PointSize`). |
-| `atlasWidth`, `atlasHeight`, `atlasPadding`, `atlasRenderMode`, `atlasPopulationMode` | The atlas the glyph rects refer to: its size, the padding (texels of distance field around each glyph, `_GradientScale` = padding + 1), the `GlyphRenderMode` and the population mode (0 static, 1 dynamic). |
-| `atlases` | The atlas page names (`atlasIndex` of a glyph indexes them). |
-| `normalStyle`, `normalSpacingOffset`, `boldStyle`, `boldSpacing`, `italicStyle`, `tabSize` | TMP font asset style settings. |
-| `material` | The asset's default material (a key of `materials`). |
-| `fallbacks` | Names of the fallback font assets (keys of `fonts`), in search order: TextMeshPro's depth-first search over the fallback tables (each asset once), reduced to the assets in `fonts`. A character the asset lacks is taken from the first of them that has it ([Fallback font assets](#fallback-font-assets)). |
-| `characters` | Code point (decimal string) → `{ glyph, scale, elementType }`: the glyph index (a key of `glyphs`). |
-| `missingGlyph` | Optional: `{ unicode, characters }`: the code points of the episode's texts that the game's font asset lacks with its fallbacks (`characters`, ascending), which TextMeshPro draws as its missing glyph: the character `unicode`, `TMP_Settings.missingGlyphCharacter` (0: U+25A1) when the game's font asset or a fallback has it, else U+0020, else U+0003. The asset or one of its `fallbacks` holds `unicode`, except U+0003, a control character TextMeshPro synthesizes; none of them holds a code point of `characters`. A text with a sprite asset draws those of them its sprite asset has as sprites. A variation selector (U+FE00–U+FE0F, U+E0100–U+E01EF) right after a character of a font asset is not drawn (TextMeshPro replaces it by U+001A, which it skips); after a sprite or a tag it is a character like any other. |
-| `glyphs` | Glyph index (decimal string) → `{ metrics, rect, scale, atlasIndex, packed, runtime }`: `metrics` (`m_Width`, `m_Height`, `m_HorizontalBearingX`, `m_HorizontalBearingY`, `m_HorizontalAdvance`, px at the point size), `rect` (`m_X`, `m_Y`, `m_Width`, `m_Height`, texels of the atlas, origin bottom left), `scale`, `atlasIndex` (page, or `null` for a glyph a dynamic asset adds at runtime), `packed` (`{ texture, dx, dy }`: the glyph page of `textures` holding the glyph's texels and the integer offset from `rect` to them; absent for an empty rect), `runtime` (optional, `true`: generated as a dynamic font asset adds it). |
-| `glyphPairAdjustmentRecords`, `glyphPairAdjustments` | The number of glyph pair adjustment records of the asset and, when it is not 0, the lookup reduced to the exported glyphs: key (`first | second << 16`) → `{ first, second, flags }` with value records `{ xPlacement, yPlacement, xAdvance, yAdvance }`. |
-| `runtimeCharacters`, `runtimeGlyphs` | Game data: the characters a dynamic asset generates at runtime and how (else `[]` and `null`). |
-| `sourceFont` | Game data: the asset's source font file (`name`, `bytes`, `sha256`), or `null`. |
-| `source` | Open data: the font file the glyphs were generated from: `family`, `style`, `version`, `license` (the font's license name or URL as the file states it), `file` (file name), `faceIndex`, `bytes`, `sha256`, and `generator` (how the glyphs were rasterized). |
-| `browser` | Optional. A font asset whose glyphs the browser draws: `{ family, weight?, style?, pageWidth?, pageHeight?, underlayOffset?, gameFont? }`. The player makes each character's glyph when a text first uses it, with the font asset's point size, `atlasPadding` and `atlasRenderMode`, and keeps `characters` and `glyphs` as the data lists them (start with `{}`). Text layout is TextMeshPro's, from the glyph metrics; see below. |
-| `subset` | Which characters the asset holds. |
-
-Every font asset a binding names in `localized.fontAsset` holds U+005F `_` when its font has it: TextMeshPro's
-underline and `<mark>` highlight draw with the `_` glyph of the text's own font asset (no fallback), sampled on the
-asset's first page. Open data put it on page 0; game data keep the game asset's glyph and record in
-`coverage.underline` (`font`, `character`, `inAsset`) whether the full game asset has it, so that a missing `_` is
-told apart from a reduced glyph set.
+Each `texts[componentId]` contains `font: {fontAsset, material, lineSpacing}`, `localized` and `style`; it may also
+contain Korean font adjustment settings. `font` is the drawable binding. `localized` records the original localized
+font selection and can name a font absent from an open-font product.
 
-### Browser fonts
+### Font assets
 
-A font asset with `browser` has no atlas file. The player draws each glyph of `family` (a CSS font-family list the page can render: an installed font, a `@font-face`, or a `FontFace` added to `document.fonts` before the story starts) on Canvas 2D and builds its SDF the way the open-font data are made:
+`fonts` maps font names to TMP face metrics, atlas dimensions and padding, render mode, style/spacing values,
+character and glyph tables, fallback names, and a default material. `characters[unicode].glyph` names a glyph.
+Its rect, metrics and scale control layout. A glyph with image texels has `packed: {texture, dx, dy}`; its rect plus
+the offset must fit within the named page. Empty glyphs, such as spaces, do not need packed texels.
 
-- the glyph box (bearings, size, advance with 1/64 px precision) at `faceInfo.m_PointSize`; the cell is the box with each edge rounded to the nearest pixel (ties outwards), grown by a margin of `ceil(_GradientScale) + ceil(underlayOffset × _GradientScale) + 1` texels, where `_GradientScale` is `atlasPadding + 1`;
-- the glyph is drawn 8 × larger for the render modes SDF8, SDF16 and SDF32 (8230, 16422, 32806) and once for the others; a pixel is inside when its alpha reaches one half;
-- each texel holds `alpha = floor(255 × clamp(0.5 + d / (2 × (atlasPadding + 1)), 0, 1) + 0.5)`, `d` the exact Euclidean distance from an inside pixel to the nearest outside pixel (negative for an outside pixel: minus the distance to the nearest inside one), the mean over the central 2 × 2 fine pixels divided by 8 when drawn larger; the other channels are 0.
+`textures` describes page PNGs under the font product. `missingGlyph` records absent code points and the substitute
+TMP draws; the substitute must exist in the font or its fallbacks, or be TMP's synthesized U+0003 control glyph.
+`coverage.missingGlyph` collects those substituted code points across fonts.
 
-The cells are packed in rows on one page of `pageWidth` × `pageHeight` texels (2048 × 2048 by default), U+005F first. The page is a texture the player owns (`<font asset name>#browser`); a text that needs more characters than the page holds raises an error that names the page size. `gameFont` names a font asset of the game (`A-OTF-ShinGoPr6N-Regular SDF`, `VibeMOPro-Medium SDF`, `FZLTH_GB18030L2_R SDF`, `Pretendard-SemiBold SDF`) whose line height, ascent and descent replace the asset's own, as for open fonts. `faceInfo` is read as it stands (the player does not measure the font), and a fallback of a browser font asset is a font asset of the data.
+### Browser fonts
 
-The glyph raster of a browser differs from a font file's outline raster in anti-aliasing and hinting, so the field's values at an edge can differ by a fraction of a texel from the open-font data of the same font; the layout is the same function of the glyph metrics.
+A font asset can have `browser: {family, weight?, style?, pageWidth?, pageHeight?, underlayOffset?, gameFont?}`.
+The browser rasterizes glyphs as the text uses them, retaining the font asset's TMP layout metrics and SDF padding.
+This is the font mode used by story-author for authored text. Character and glyph tables can start empty.
 
 ### Fallback font assets
 
-A text finds a character as `TMP_Text.GetTextElement` does: in its font asset, then in the asset's `fallbacks` in
-order, then in its sprite asset; a character none has takes the missing glyph (`missingGlyph`), which is looked up the
-same way. A character from a fallback asset is laid out with that asset's face info, glyph metrics and style
-settings, and drawn from that asset's pages with the fallback material of the text's material:
-`TMP_MaterialManager.GetFallbackMaterial` (TMP Settings' `matchMaterialPreset`), a material named
-`<text material> + <fallback asset>` in `materials`, which holds the text material's shader, keywords and values
-except `_MainTex`, `_GradientScale`, `_TextureWidth`, `_TextureHeight`, `_WeightNormal` and `_WeightBold`,
-which are those of the fallback asset's default material, and `_ScaleRatioA` / `_ScaleRatioC`, which are
-`ShaderUtilities.UpdateShaderRatios` of the result (float32). Every text material of a binding has one per fallback
-of its font asset.
-
-Open data mirror the game's chains. The open asset standing for a game font asset has as fallbacks the open assets
-standing for the game asset's fallbacks: the one for a game asset is drawn from the font file of the language
-`LocalizeManager` lists that asset for (the language of the document when it lists it, else the first in
-LanguageMode order); the game's own fallback assets that no language lists have none. A fallback asset holds the
-characters of the texts that the assets before it in the chain lack and its font file has, and U+005F only when a
-text shows it there; an asset that would hold no character is left out.
-
-A glyph's texels are the texels `rect` + (`dx`, `dy`) of its page (the same sampling as the full atlas: the page holds
-each glyph with the texels a draw can sample around it). A material's `_TextureWidth` / `_TextureHeight` are those of
-the atlas; a renderer that samples a page instead uses the page's size for the texel-space terms, as TextMeshPro does
-for its atlas.
-
-Open font assets (`source` `open`) hold the characters of the episode's text table, its title, the static labels of
-the UI, the chat windows' status texts, the serialized texts of the chat windows' text nodes (shown until a row sets
-them) and the texts the chat windows format at run time (battery percentages, member counts, read counts, the ellipsis
-of a shortened name) and the texts the frames that receive texts get at run time (`AdvFrameCommand.SetFrameTexts`:
-the texts of the Frame rows' `TargetTextIDs`, normalized to NFC, with `@` and line feeds). They keep TextMeshPro's
-scale relations: each takes the point
-size, padding and style settings of the game font asset the text uses in that language, its face info and glyph metrics come from the font
-file at that point size, and its materials are the game's text materials of that language with the page as
-`_MainTex`. A game asset of an anti-aliased distance-field render mode (`SDFAA`) gets a distance field of the same
-spread, recorded as `SDF` in `atlasRenderMode` (the game render mode is in `source.generator`). A character the
-language's font file lacks is taken from the fallback chain ([Fallback font assets](#fallback-font-assets)); one no
-font file of the chain has is in `coverage.missing`. Line breaks can differ from the game where the font's advances
-differ; the layout rules are the same.
+Each font's `fallbacks` list names other font assets. A text material `M` drawing fallback font `F` uses material
+`M + F`. It retains the text material's shader, keyword and appearance values, while taking the fallback's texture,
+gradient scale and weight values; shader scale ratios are recomputed. The validator checks these relationships.
 
 ### Sprite assets
 
-A sprite asset is a TextMeshPro sprite asset (`TMP_SpriteAsset`) reduced to the sprites the episode's texts can draw:
-TextMeshPro draws a character a text's font assets lack from the text's sprite asset when it has a sprite of that code
-point, and a `<sprite name="...">` tag from the sprite of that name; the emoji search of the emoji texts
-(`TMP_EmojiSearchEngine`) turns emoji sequences into such tags.
-
-| Key | Meaning |
-|---|---|
-| `faceInfo` | TMP `m_FaceInfo` of the sprite asset. A point size of 0 (the game's emoji asset) scales a sprite by the face of the text's font asset: element scale = font scale × ascent line / glyph height × character scale × glyph scale. |
-| `characters` | The sprite character table in its order: `{ index, unicode, name, glyph, scale }` (`index` = the position in the game asset's table; `glyph` a key of `glyphs`). By code point the first character of the table counts, by name the first whose name has the tag value's hash (`TMP_TextUtilities.GetHashCode`, case-insensitive). |
-| `glyphs` | Glyph index → `{ metrics, rect, scale, atlasIndex, packed }` as for font assets; `rect` and `packed` locate the sprite's texels in its page (a sprite without an image has an empty `rect` and no `packed`: it keeps its place and draws nothing). |
-| `sequences` | The entries of the asset's legacy sprite list whose name holds a `-` (`{ name, unicode }`, in order): the emoji search builds its sequence table from them (`TryUpdateSequenceLookupTable`). |
-| `material` | The sprite material (a key of `materials`, shader `TextMeshPro/Sprite`, `_MainTex` the page). |
-| `source` | Open data: the emoji font the images were drawn from (as for font assets), or `null` without one. |
-| `subset` | Open data: which sprites the asset holds. |
-
-A sprite quad's uvs are its glyph rect over its page size; its colour is white with the text's font colour alpha
-(sprites are not tinted); the sprites of a text draw after its glyphs, as the sub mesh of the sprite material. Open
-data draw each image from the emoji font at the game glyph's size (the bitmap centred in a square, resampled) into one
-page with a transparent texel around each sprite; game data keep the game's sprite sheet.
+Optional `spriteAssets` contains TMP sprite characters, glyphs, sequences, face metrics and material bindings.
+`emojiSpriteAsset` names the selected emoji asset. `sprites[componentId].spriteAsset` binds a TMP text to it; the
+component's `m_tintAllSprites` field controls tinting. Sprite materials use `TextMeshPro/Sprite`.
 
-## Language (`ui/languages.json`)
+## Language
 
-([schema](../schema/story-language.schema.json)) The settings of the group's language.
+`ui.json.language` has `code`, numeric `mode`, episode text `field`, `lineSpacing`, primary and additional font names,
+material types and font swaps. The modes are Japanese 0, English 1, Traditional Chinese 2, Simplified Chinese 3 and
+Korean 4. Language settings belong to the UI product.
 
-```json
-{ "format": "ournotes.story-language/1", "language": "en", "mode": 1, "field": "english", "lineSpacing": -100,
-  "fonts": "open", "roles": { "primary": { "fontAsset": "Noto Sans CJK JP Regular SDF", "lineHeightEm": 1.448,
-                                            "ascentEm": 1.16, "descentEm": -0.288, "spacingOffset": 0,
-                                            "boldSpacing": 7 } } }
-```
+## Media files
 
-| Key | Meaning |
-|---|---|
-| `format` | `"ournotes.story-language/1"`. |
-| `language` | The language code. |
-| `mode` | `Fwk.Localization.LanguageMode` (0 ja, 1 en, 2 zh-Hant, 3 zh-Hans, 4 ko). |
-| `field` | The text field of the language in `episode.json` (`english`, …). |
-| `lineSpacing` | The line spacing localized texts get in this language (`LocalizeManager`). |
-| `fonts` | `open` or `game`, as the manifest. |
-| `roles` | Font role → `fontAsset` (the asset of `ui/fonts.json` the role's texts use) and its line metrics in em (`lineHeightEm`, `ascentEm`, `descentEm`) with `spacingOffset` and `boldSpacing` (1/100 em). |
+A `story.asset` document has `format: 1`, its `key`, root `objects`, animation `bindings` and `shaders`.
+Frames, stills, particle effects, post effects, chat windows/icons/stamps, transitions and stages use their serialized
+prefab or MonoBehaviour fields and object references. Text inside these prefabs uses the same component-id font table.
 
-The typewriter timing is not language data: `_waitTalkTextUnitTime` and the other talk timings are in the player
-settings.
+A video document has `format: 1`, its product-relative `file`, coded/display dimensions, frame rate, frame count and
+track information. The player presents it on the native VideoView canvas.
 
-## Media files
+A host document has `format: "nnnotes.story-host/1"`, `kind`, prefab references, capture `cameraTarget`, `overlayRoot`,
+`layoutRoot`, `openedSequences`, DOTween and graphics settings, bindings and shaders. A node reference is
+`{prefab, path}`; the layout root also carries its layout component `fields`.
 
-`frames.json`, `effects.json`, `posteffects.json`, `stills.json`, `talkwindows.json` and `chat.json` hold the episode's
-frames, particle effects, post-effect volume profiles, stills, talk windows and chat assets, each keyed by the asset
-name the rows name; their textures are in `textures/` and their shaders in `shaders/`. Their text components keep
-their layout and style; their fonts are the story UI's (the chat windows' text records and bindings are in
-`ui/ui.json` and `ui/fonts.json` `chatTexts`). `videos/videos.json` lists the videos (`VideoID` → file, size,
-duration) with the WebM files (VP9 video, Opus audio) next to it. The player reads `frames.json` (Frame rows),
-`effects.json` (Effect), `posteffects.json` (PostEffect), `stills.json` (Still), `chat.json` (the chat rows) and the
-videos (Movie, Clip); `talkwindows.json` is not read yet (the story UI's default talk window is used).
-
-An `Animator` component of these prefabs names its controller in `m_Controller` (`null`: none). A file holds each
-controller and each clip in full once, where it first uses it: an `AnimatorController` record (`controller` its name,
-`clips`, `layers`, `stateMachines` with the states, their motions as indices into `clips` and their transitions,
-`parameters`, `defaultValues`) whose clips are [Mecanim clips](data-format.md#note-assets-livenotesnotesjson) (`clip`
-their name). Every later use in the same file, in the same prefab or another one, is a reference by name:
-`{"controller": <name>}` for a controller, `{"clip": <name>}` for a clip in a controller's `clips`. A reference
-resolves to the full record of that name in the same file; when the file holds two different full records under one
-name, a reference to that name is ambiguous and the player refuses it. Of two frames that share a controller, only
-the first one in the file carries it in full.
-
-Particle systems (in `effects.json`, `frames.json`, `stills.json` and the stage prefabs of `scene.json`) keep the module
-structure of the live's particle systems ([Note assets](data-format.md#note-assets-livenotesnotesjson)), with two
-references of their own:
-
-- A Sub Emitters entry (`SubModule.subEmitters[].emitter`) names its system as
-  `{"component": "ParticleSystem", "gameObject": <node path>}`, a node of the same prefab; the host resolves it once
-  every system of the prefab exists (`linkSubEmitters`).
-- A Mesh shape (`ShapeModule.type` 6) carries its mesh in `ShapeModule.m_Mesh` as `{vertices, normals, uv0, submeshes}`:
-  vertex positions, normals and the first UV set as arrays of vectors, and one triangle index list per submesh.
+The home host references room and spot products and a background state keyed by node path. Room summaries preserve
+node order and `materialIds`, matching the GLB's primitive material indices. The host applies activation and floor
+queue overrides. Spine materials are resolved from each SkeletonAnimation's skeleton and atlas object references.
+The afterlive host identifies the background image/sprite, reward panel and result-screen substitutes.
 
 ## Documents and identities
 
-`stories.json`, the manifests, `ui/fonts.json` and `ui/languages.json` are written as canonical JSON: UTF-8, LF, one
-trailing newline, keys sorted, indent 1, non-ASCII characters as they are, `1e999` / `-1e999` for infinity. Asset
-names are SHA-256 content ids. The documents hold no timestamps and no absolute paths: the same inputs give the same
-bytes. `format` strings name the document and its version (`ournotes.<document>/<version>`); a reader refuses a
-version it does not know.
+The same object id must have compatible metadata wherever it appears. Products may retain different file roles of
+that object, which merge into one object table. Two copies of the same role must agree. Animation bindings remain
+specific to a prefab and Animator path even when clips share names.
 
 ## Validation
 
-```
-node scripts/validate-data.mjs <site dir> [chart id | model id | story id ...]
+```sh
+node scripts/validate-data.mjs <site-dir> [story-id ...]
+node scripts/validate-data.mjs <site-dir> 7 --lang=ja,en
 ```
 
-Besides the charts and models, validates `stories.json` and every story (or the given story ids; a story id is the
-`advId`, or `<region>/<advId>` for a region's own manifest). Per story:
-
-- the manifest (schema, the language group rules above, agreement with `stories.json`: facts, sizes, `regions`;
-  `root` as the manifest's place in the site gives it and no file under `live2d/`);
-- every asset of `files` and of every language group, as for charts (present, an encoded asset's stored length and
-  decoding, byte size, SHA-256 of the decoded bytes equal to its name, extension matching the logical file, split JSON
-  rebuilt to its `size`, JSON parses);
-- `story.json` and `episode.json` (schemas; every path `story.json` names is in the common files; every cue sheet the
-  episode's cue sheet table names has its `cues.json` when `audio` is true, and every file a `cues.json` names is
-  present with the manifest's `audioFormat`, FLAC `STREAMINFO` or MP4 header agreeing with the cue; without audio no
-  cue sheet and no waveform file); `story.json` `crilips`, when set, only with audio, both files common, the
-  descriptor float32 little-endian with every block inside `crilips.bin`;
-- the models: `models` keys sorted, each path `models/<id>.json`, the same ids as `story.json` `models`, each
-  Character row's model among them, each model manifest present (in `models.json` when the site has one) and valid as
-  a model ([Validation](data-format.md#validation)), which includes the programs the story renderer draws with at
-  every quality;
-- `requires.commands` equal to the facts' `commands` and to the command names of the episode's rows without
-  `IgnoreData` together with the player settings' initialize and finalize rows; `requires.motionSync` as the
-  episode's rows give it;
-- `host` present exactly for an Overlay episode with open fonts; `host/host.json` a common file of format
-  `ournotes.story-host/1` with the manifest's `kind`, its `ui` document a common file;
-- in each media file, every controller and clip reference resolves to a full record of its name in the file, and no
-  two different full records share that name ([Media files](#media-files));
-- per language: `ui/ui.json` (node order), `ui/languages.json` and `ui/fonts.json` (schemas; `language` equal to the
-  group's, `mode` and `field` those of the language; every text node of that language's `ui/ui.json` has a binding
-  whose `localized` font asset and material exist, and every binding is a text node; with open fonts the same for
-  the text nodes of `dialogs` (`dialogTexts`), the texts of `chatTexts` and the text nodes of the frames of
-  `frames.json` (`frameTexts`), with game fonts none of them; fallbacks, material keys, `characters` → `glyphs`
-  references, glyph pages named by `packed` present in the group with their described size; every glyph's `rect` +
-  offset inside its page; `fallbacks` without the asset itself and without repeats, and the fallback material of
-  every binding's text material per fallback of its font asset, with the values `GetFallbackMaterial` gives; a font
-  asset's `missingGlyph` as described above (with `tmpSettings`, also which character
-  `unicode` is) and `coverage.missingGlyph` equal to the characters of all of them; with `spriteAssets`:
-  `emojiSpriteAsset` one of them, each sprite asset's material of shader `TextMeshPro/Sprite`, its characters in index
-  order with their glyphs, its glyph pages as for font assets, `coverage.sprites` (the characters held, the missing
-  names those of sprites without an image), and the sprite asset of every binding that has one equal to
-  `emojiSpriteAsset`, with `m_tintAllSprites`; without `spriteAssets` no binding has one); with a `host`,
-  `ui/simple/ui.json` and `ui/simple/fonts.json` checked the same way;
-- the shader directories `shaders/` and `ui/shaders/` (index, parsed files, GLSL ES 3.00 blocks), that `ui/shaders/`
-  has a variant for every UI and text material's `materialKeywords`, and that every PNG a texture descriptor of the
-  scene, the media files or the UI names has the described size.
+By default, validation checks every declared language. `--lang` explicitly restricts language validation and the
+summary names that scope. Checks cover product identities, content-addressed files, shared objects, scene/UI/host
+references, animation binding tables, actual material shader variants, glyph pages, font fallbacks, cue waveforms,
+CRI Lips data bounds and model products. Rendered output is verified separately with a browser.
diff --git a/docs/story-features.md b/docs/story-features.md
index 25c6253..1cdbe86 100644
--- a/docs/story-features.md
+++ b/docs/story-features.md
@@ -27,12 +27,10 @@ interpreter's commands, every `AdvCommand` has a handler (`registeredCommands()`
 
 ## Data
 
-The features read the media files that `story.json` names (`frames`, `stills`, `videos`, `effects`, `postEffects`,
-`chat`) and the story UI data (`ui/ui.json`: the video, still, frame and screen canvases, the video and still camera,
-the screen image, the story UI shaders; `ui/fonts.json` `frameTexts`: the text bindings of the frames' text nodes).
-A file is read only when the episode has rows that use it. When a record
-contradicts what the player implements (a canvas with another render mode or scaler, a camera with other clear flags,
-projection, volume mask or volume update mode), the episode is refused with the record's path.
+The features resolve `story.json.parts.assets`, `.videos` and `.chat` products. Prefab components hold the media
+fields, canvas and camera settings; object ids identify textures, meshes, materials, clips and controllers.
+The story UI product supplies its canvas prefabs, and the font product binds text by TMP component id.
+A setting outside the implemented subset is reported with its object or node path when the feature is initialized.
 
 ## What is drawn
 
@@ -76,9 +74,8 @@ projection, volume mask or volume update mode), the episode is refused with the
   copies the first one), the sender identity and read labels, the typing box and its height, the typing padding of the
   timeline and the scroll to the bottom. The canvas is a layer 11 renderer of the field (sorting order 10000, at the
   canvas' plane distance): in the camera's list, or after the offscreen composite while the foreground entry is active.
-  A drawing session needs the story UI's chat data (`ui/ui.json` `chatWidget` and `chatTexts`, `ui/fonts.json`
-  `chatTexts`) and refuses a chat episode without it; a headless session with that data lays the phone out as well,
-  without it it keeps the same state without the layout (the scroll tweens run on a 0 position).
+  The story UI product references `chatWidget`, chat window/icon/stamp products provide their prefabs, and
+  `story.fonts.texts` binds their TMP components. A missing binding is reported with the component's identity.
 
 ## What is not drawn
 
diff --git a/docs/story-simple.md b/docs/story-simple.md
index b25637d..df6026f 100644
--- a/docs/story-simple.md
+++ b/docs/story-simple.md
@@ -31,7 +31,7 @@ full story player. `src/story/simple/` reproduces that presentation. `StorySessi
 
 ## Hosts
 
-`host/host.json` (written by the data exporter for Overlay episodes) names the host screen:
+`host.json` in the `story.host` product names the host screen:
 
 | Host | Screen | Reproduced | Not reproduced (runtime data) |
 |---|---|---|---|
@@ -63,21 +63,19 @@ main camera with antialiasing or dithering.
 
 ## Data
 
-Besides the story files of `docs/story-data-format.md`:
-
-- `host/host.json` (`ournotes.story-host/1`): the host kind, the capture camera prefab values (`cameraTarget`), the
-  host's overlay root and its layout component (`overlayRoot`, `layoutRoot`), the host UI document (`ui`:
-  `host/ui/ui.json`), the sequences the host screen has played when a talk can start (`openedSequences`: the talk
-  starts with their Animator states at their end), and per host its scene data (`home`: the spot export, the room
-  glTF with the background root's transform, per-node visibility after the situation, materials, Spine materials and
-  sorting, shaders, blur parameters, ambient sound, the spot scene's camera and render settings, the lights of the
-  scene and the placed prefabs, and the volumes of the scene and the background; `afterlive`: the background node and
-  sprite, the reward panel, the list of runtime parts not drawn).
-- `ui/simple/ui.json`, `ui/simple/fonts.json` (per language): the talk window (and, for area talks, the system message
-  widget and its title text) in the story UI record format, with the fonts of its texts.
-- Animator clips of the host UI key their curves by the path below the Animator (`"<path>:<Class>.<property>"`);
-  sprite curves index the clip's sprite names. A curve whose object is not in the exported part of the screen is
-  bound to nothing, as Unity does for a missing object.
+The [story part index](story-data-format.md#storyjson) names the reusable host and language products.
+
+- `story.host` contains `host.json` (`nnnotes.story-host/1`), prefab ids, capture camera, overlay and layout references,
+  opened animation sequences, graphics and DOTween settings. Node references are `{prefab, path}`. Home hosts also
+  reference room and spot products, background activation/queue state and scene roots. Afterlive hosts identify the
+  background image/sprite and reward panel.
+- `story.simpleui` contains `ui.json` (`nnnotes.story-simple-ui/1`), referencing the simple talk window and system
+  message prefabs. Native components hold their text, layout and animation fields.
+- `story.fonts` supplies the selected language's TMP component-id bindings and glyph pages. The episode's own
+  `story.json.host` selects the home talk kind, tap character and localized area title.
+
+The loader merges these products' compatible object roles. Room geometry and material order come from `room.json`
+and `room.glb`; Spine files come from the spot product, with page materials resolved from its skeleton/atlas objects.
 
 ## Page requirements
 
diff --git a/docs/story.md b/docs/story.md
index f2ba2a4..a7aaf4e 100644
--- a/docs/story.md
+++ b/docs/story.md
@@ -182,14 +182,11 @@ with the distance: from the current time forward, from the clip's start backward
 
 ## Episodes the player refuses
 
-The player refuses an episode it cannot play as the game does, naming what is missing: a command without a handler
-(the command registry below; checked from the manifest before the story's files download), a stage feature it does
-not draw (stage shadow textures), a talk window the story UI does not provide, a text the story UI cannot lay out, and
-in a session that draws, a chat episode without the story UI's chat data (`ui/ui.json` `chatWidget` and `chatTexts`,
-`ui/fonts.json` `chatTexts`) and a frame text without the story UI's frame text bindings (`ui/fonts.json`
-`frameTexts`). Such an episode is never played
-halfway. The one exception is a graphic found only while drawing: a still canvas that shows a UIParticle effect
-stops the session at that frame with an error that names the node and the component.
+The loader checks the episode's command set before downloading media. Sessions report unsupported settings and
+missing resources with the command, node or object identity: an unavailable talk window, stage shadow textures,
+text layout features outside the supported subset, or a TMP text without a font-product binding. A resource first
+needed by a later command or draw can fail at that point. Supported feature subsets are listed in
+[story-features.md](story-features.md).
 
 ## Extending: the command registry
 
diff --git a/schema/episode.schema.json b/schema/episode.schema.json
index ce69391..2c8b3f3 100644
--- a/schema/episode.schema.json
+++ b/schema/episode.schema.json
@@ -4,101 +4,302 @@
   "title": "Story episode (episode.json)",
   "description": "One story episode: its command rows (non-default fields under their serialized names), texts per text field, the episode's sound, cue sheet and video rows, its asset closure, master data row and title. Only the keys the player reads are described. See docs/story-data-format.md.",
   "type": "object",
-  "required": ["advId", "asset", "commandCount", "commands", "text", "sounds", "cuesheets", "videos", "resources", "master", "title"],
+  "required": [
+    "advId",
+    "asset",
+    "commandCount",
+    "commands",
+    "text",
+    "sounds",
+    "cuesheets",
+    "videos",
+    "resources",
+    "master",
+    "title"
+  ],
   "properties": {
-    "advId": { "type": "integer", "minimum": 1 },
-    "asset": { "type": "string", "minLength": 1 },
-    "commandCount": { "type": "integer", "minimum": 0 },
-    "commands": { "type": "array", "items": { "$ref": "#/$defs/command" } },
-    "text": { "type": "object", "additionalProperties": { "$ref": "#/$defs/texts" } },
+    "advId": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "asset": {
+      "type": "string"
+    },
+    "commandCount": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "commands": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/command"
+      }
+    },
+    "text": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/texts"
+      }
+    },
     "sounds": {
       "type": "object",
       "additionalProperties": {
         "type": "object",
-        "properties": { "_cueName": { "type": "string" }, "_soundCueSheetID": { "type": "integer" } }
+        "properties": {
+          "_cueName": {
+            "type": "string"
+          },
+          "_soundCueSheetID": {
+            "type": "integer"
+          }
+        }
       }
     },
     "cuesheets": {
       "type": "object",
       "additionalProperties": {
         "type": "object",
-        "required": ["_cueSheetName"],
-        "properties": { "_cueSheetName": { "type": "string", "minLength": 1 } }
+        "required": [
+          "_cueSheetName"
+        ],
+        "properties": {
+          "_cueSheetName": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "videos": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object"
       }
     },
-    "videos": { "type": "object", "additionalProperties": { "type": "object" } },
     "resources": {
       "type": "array",
       "items": {
         "type": "object",
-        "required": ["kind", "address", "present"],
+        "required": [
+          "kind",
+          "address"
+        ],
         "properties": {
-          "kind": { "type": "string", "minLength": 1 },
-          "address": { "type": "string", "minLength": 1 },
-          "present": { "type": "boolean" }
+          "kind": {
+            "type": "string",
+            "minLength": 1
+          },
+          "address": {
+            "type": "string",
+            "minLength": 1
+          },
+          "present": {
+            "type": "boolean"
+          }
         }
       }
     },
     "master": {
       "type": "object",
-      "required": ["_id", "_advEpisodeAsset", "_titleTextId", "_playbackMode"],
+      "required": [
+        "_id",
+        "_advEpisodeAsset",
+        "_titleTextId",
+        "_playbackMode"
+      ],
       "properties": {
-        "_id": { "type": "integer", "minimum": 1 },
-        "_sheetName": { "type": "string" },
-        "_advEpisodeAsset": { "type": "string", "minLength": 1 },
-        "_titleTextId": { "type": "string" },
-        "_rubyTitleTextId": { "type": "string" },
-        "_playbackMode": { "enum": [0, 1] }
+        "_id": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "_sheetName": {
+          "type": "string"
+        },
+        "_advEpisodeAsset": {
+          "type": "string"
+        },
+        "_titleTextId": {
+          "type": "string"
+        },
+        "_rubyTitleTextId": {
+          "type": "string"
+        },
+        "_playbackMode": {
+          "enum": [
+            0,
+            1
+          ]
+        }
       }
     },
-    "title": { "anyOf": [{ "type": "null" }, { "$ref": "#/$defs/texts" }] }
+    "title": {
+      "anyOf": [
+        {
+          "type": "null"
+        },
+        {
+          "$ref": "#/$defs/texts"
+        }
+      ]
+    }
   },
   "$defs": {
     "texts": {
       "type": "object",
-      "required": ["japanese", "english", "traditionalChinese", "simplifiedChinese", "korean"],
       "properties": {
-        "japanese": { "type": ["string", "null"] },
-        "english": { "type": ["string", "null"] },
-        "traditionalChinese": { "type": ["string", "null"] },
-        "simplifiedChinese": { "type": ["string", "null"] },
-        "korean": { "type": ["string", "null"] }
+        "japanese": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "english": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "traditionalChinese": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "simplifiedChinese": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "korean": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
       }
     },
     "command": {
       "type": "object",
-      "required": ["i", "cmd", "raw"],
+      "required": [
+        "i",
+        "cmd",
+        "raw"
+      ],
       "properties": {
-        "i": { "type": "integer" },
-        "cmd": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9]*$" },
-        "raw": { "type": "integer", "minimum": 0 },
-        "TargetName": { "type": "string" },
-        "TargetAssetName": { "type": "string" },
-        "TargetAssetIndex": { "type": "integer" },
-        "PositionType": { "type": "integer" },
-        "CameraDistance": { "type": "number" },
-        "Duration": { "type": "number" },
-        "DelaySeconds": { "type": "number" },
-        "IsNoWait": { "type": ["boolean", "integer"] },
-        "IgnoreData": { "type": ["boolean", "integer"] },
-        "IgnoreLipSync": { "type": ["boolean", "integer"] },
-        "Parameter1": { "type": "string" },
-        "Parameter2": { "type": "string" },
-        "Parameter3": { "type": "string" },
-        "Parameter4": { "type": "string" },
-        "TargetTextIDs": { "type": "array", "items": { "type": "string" } },
-        "TargetStatus": { "type": "integer" },
-        "AdvTextID": { "type": "string" },
-        "lines": { "$ref": "#/$defs/texts" },
-        "VoiceIDs": { "type": "array", "items": { "type": "integer" } },
-        "voiceCues": { "type": "array", "items": { "type": ["string", "null"] } },
-        "MotionName": { "type": "string" },
-        "ExpressionName": { "type": "string" },
-        "BgmID": { "type": "integer" },
-        "SeID": { "type": "integer" },
-        "Key": { "type": "string" },
-        "VideoID": { "type": "integer" },
-        "TargetChatID": { "type": "integer" }
+        "i": {
+          "type": "integer"
+        },
+        "cmd": {
+          "type": "string",
+          "pattern": "^[A-Za-z][A-Za-z0-9]*$"
+        },
+        "raw": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "TargetName": {
+          "type": "string"
+        },
+        "TargetAssetName": {
+          "type": "string"
+        },
+        "TargetAssetIndex": {
+          "type": "integer"
+        },
+        "PositionType": {
+          "type": "integer"
+        },
+        "CameraDistance": {
+          "type": "number"
+        },
+        "Duration": {
+          "type": "number"
+        },
+        "DelaySeconds": {
+          "type": "number"
+        },
+        "IsNoWait": {
+          "type": [
+            "boolean",
+            "integer"
+          ]
+        },
+        "IgnoreData": {
+          "type": [
+            "boolean",
+            "integer"
+          ]
+        },
+        "IgnoreLipSync": {
+          "type": [
+            "boolean",
+            "integer"
+          ]
+        },
+        "Parameter1": {
+          "type": "string"
+        },
+        "Parameter2": {
+          "type": "string"
+        },
+        "Parameter3": {
+          "type": "string"
+        },
+        "Parameter4": {
+          "type": "string"
+        },
+        "TargetTextIDs": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "TargetStatus": {
+          "type": "integer"
+        },
+        "AdvTextID": {
+          "type": "string"
+        },
+        "lines": {
+          "$ref": "#/$defs/texts"
+        },
+        "VoiceIDs": {
+          "type": "array",
+          "items": {
+            "type": "integer"
+          }
+        },
+        "voiceCues": {
+          "type": "array",
+          "items": {
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "MotionName": {
+          "type": "string"
+        },
+        "ExpressionName": {
+          "type": "string"
+        },
+        "BgmID": {
+          "type": "integer"
+        },
+        "SeID": {
+          "type": "integer"
+        },
+        "Key": {
+          "type": "string"
+        },
+        "VideoID": {
+          "type": "integer"
+        },
+        "TargetChatID": {
+          "type": "integer"
+        }
       }
     }
   }
diff --git a/schema/product.schema.json b/schema/product.schema.json
index 7ba287b..a2da330 100644
--- a/schema/product.schema.json
+++ b/schema/product.schema.json
@@ -4,61 +4,144 @@
   "title": "Product manifest (nnnotes.product/1)",
   "description": "A product's files and the files of the objects it uses (its object table), each a content-addressed asset relative to the site root; a Live2D model's manifest models/<id>.json is one, of product live2d.model. See docs/data-format.md.",
   "type": "object",
-  "required": ["schema", "product", "subject", "files", "objects"],
+  "required": [
+    "schema",
+    "product",
+    "subject",
+    "files",
+    "objects"
+  ],
   "additionalProperties": false,
   "properties": {
-    "schema": { "const": "nnnotes.product/1" },
-    "product": { "type": "string", "pattern": "^[a-z][a-z0-9]*(\\.[a-z][a-z0-9-]*)*$" },
-    "subject": { "type": "string", "minLength": 1 },
+    "schema": {
+      "const": "nnnotes.product/1"
+    },
+    "product": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9]*(\\.[a-z][a-z0-9-]*)*$"
+    },
+    "subject": {
+      "type": "string",
+      "minLength": 1
+    },
     "files": {
       "description": "The product's own files by logical path.",
       "type": "object",
-      "propertyNames": { "pattern": "^[A-Za-z0-9_][^\\\\]*$" },
-      "additionalProperties": { "$ref": "#/$defs/file" }
+      "propertyNames": {
+        "pattern": "^[A-Za-z0-9_][^\\\\]*$"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/file"
+      }
     },
     "objects": {
       "description": "Object id (<serialized file>:<path id>) -> the object's class, name and files by role (json, image, index, program:<platform>/<name>, blob:<field>).",
       "type": "object",
-      "propertyNames": { "pattern": "^.+:-?[0-9]+$" },
+      "propertyNames": {
+        "pattern": "^.+:-?[0-9]+$"
+      },
       "additionalProperties": {
         "type": "object",
-        "required": ["class", "files"],
+        "required": [
+          "class",
+          "files"
+        ],
         "additionalProperties": false,
         "properties": {
-          "class": { "type": "string", "minLength": 1 },
-          "name": { "type": "string" },
+          "class": {
+            "type": "string",
+            "minLength": 1
+          },
+          "name": {
+            "type": "string"
+          },
           "files": {
             "type": "object",
-            "additionalProperties": { "$ref": "#/$defs/file" }
+            "additionalProperties": {
+              "$ref": "#/$defs/file"
+            }
           }
         }
       }
+    },
+    "root": {
+      "type": "string",
+      "minLength": 1
+    },
+    "language": {
+      "enum": [
+        "ja",
+        "en",
+        "zh-Hant",
+        "zh-Hans",
+        "ko"
+      ]
     }
   },
   "$defs": {
-    "file": { "anyOf": [{ "$ref": "#/$defs/whole" }, { "$ref": "#/$defs/encoded" }] },
-    "asset": { "type": "string", "pattern": "^assets/[0-9a-f]{64}\\.[a-z0-9]+$" },
+    "file": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/whole"
+        },
+        {
+          "$ref": "#/$defs/encoded"
+        }
+      ]
+    },
+    "asset": {
+      "type": "string",
+      "pattern": "^assets/[0-9a-f]{64}\\.[a-z0-9]+$"
+    },
     "encodedAsset": {
       "description": "An asset stored gzip- or brotli-encoded: the SHA-256 of its decoded bytes, the file's extension, then .gz or .br.",
       "type": "string",
       "pattern": "^assets/[0-9a-f]{64}\\.[a-z0-9]+\\.(gz|br)$"
     },
-    "size": { "description": "The byte count of the file (decoded).", "type": "integer", "minimum": 0 },
-    "stored": { "description": "The byte count of an encoded asset as stored (less than size).", "type": "integer", "minimum": 0 },
+    "size": {
+      "description": "The byte count of the file (decoded).",
+      "type": "integer",
+      "minimum": 0
+    },
+    "stored": {
+      "description": "The byte count of an encoded asset as stored (less than size).",
+      "type": "integer",
+      "minimum": 0
+    },
     "whole": {
       "type": "object",
-      "required": ["asset", "size"],
+      "required": [
+        "asset",
+        "size"
+      ],
       "additionalProperties": false,
-      "properties": { "asset": { "$ref": "#/$defs/asset" }, "size": { "$ref": "#/$defs/size" } }
+      "properties": {
+        "asset": {
+          "$ref": "#/$defs/asset"
+        },
+        "size": {
+          "$ref": "#/$defs/size"
+        }
+      }
     },
     "encoded": {
       "type": "object",
-      "required": ["asset", "size", "stored"],
+      "required": [
+        "asset",
+        "size",
+        "stored"
+      ],
       "additionalProperties": false,
       "properties": {
-        "asset": { "$ref": "#/$defs/encodedAsset" },
-        "size": { "$ref": "#/$defs/size" },
-        "stored": { "$ref": "#/$defs/stored" }
+        "asset": {
+          "$ref": "#/$defs/encodedAsset"
+        },
+        "size": {
+          "$ref": "#/$defs/size"
+        },
+        "stored": {
+          "$ref": "#/$defs/stored"
+        }
       }
     }
   }
diff --git a/schema/story-asset.schema.json b/schema/story-asset.schema.json
new file mode 100644
index 0000000..2aeb704
--- /dev/null
+++ b/schema/story-asset.schema.json
@@ -0,0 +1,76 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-asset.schema.json",
+  "title": "Story media objects",
+  "required": [
+    "format",
+    "key",
+    "objects",
+    "bindings",
+    "shaders"
+  ],
+  "properties": {
+    "format": {
+      "const": 1
+    },
+    "key": {
+      "type": "string"
+    },
+    "objects": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "path",
+                "attribute"
+              ],
+              "properties": {
+                "path": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "attribute": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          },
+          "propertyNames": {
+            "type": "string",
+            "pattern": "^.+:-?[0-9]+$"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "shaders": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    }
+  }
+}
diff --git a/schema/story-fonts.schema.json b/schema/story-fonts.schema.json
index 6e348eb..938a32e 100644
--- a/schema/story-fonts.schema.json
+++ b/schema/story-fonts.schema.json
@@ -1,404 +1,1025 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-fonts.schema.json",
-  "title": "Story fonts (ui/fonts.json)",
+  "title": "Story font product (fonts.json)",
   "description": "The TextMeshPro font assets (reduced to the characters an episode shows in one language), their glyph pages, the text materials and the text bindings of the story UI in that language. The same format for glyphs generated from a font file (source open) and for the game's font assets (source game). See docs/story-data-format.md.",
   "type": "object",
-  "required": ["format", "language", "source", "fonts", "textures", "materials", "materialKeywords", "texts", "coverage"],
+  "required": [
+    "format",
+    "language",
+    "source",
+    "fonts",
+    "textures",
+    "materials",
+    "materialKeywords",
+    "texts",
+    "coverage",
+    "shaders",
+    "sprites",
+    "lineBreaking"
+  ],
   "properties": {
-    "format": { "const": "ournotes.story-fonts/1" },
-    "language": { "enum": ["ja", "en", "zh-Hant", "zh-Hans", "ko"] },
-    "source": { "enum": ["open", "game"] },
-    "fonts": { "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/font" } },
-    "textures": { "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/texture" } },
-    "materials": { "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/material" } },
-    "materialKeywords": {
+    "format": {
+      "const": "nnnotes.story-fonts/1"
+    },
+    "language": {
+      "enum": [
+        "ja",
+        "en",
+        "zh-Hant",
+        "zh-Hans",
+        "ko"
+      ]
+    },
+    "source": {
+      "enum": [
+        "open",
+        "game"
+      ]
+    },
+    "fonts": {
       "type": "object",
-      "additionalProperties": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+      "propertyNames": {
+        "minLength": 1
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/font"
+      }
+    },
+    "textures": {
+      "type": "object",
+      "propertyNames": {
+        "minLength": 1
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/texture"
+      }
     },
-    "texts": { "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/text" } },
-    "dialogTexts": {
-      "description": "Open fonts: dialog name (ui.json dialogs) -> text node path -> text binding.",
+    "materials": {
       "type": "object",
+      "propertyNames": {
+        "minLength": 1
+      },
       "additionalProperties": {
-        "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/text" }
+        "$ref": "#/$defs/material"
       }
     },
-    "chatTexts": {
-      "description": "Open fonts: chat window name -> text node path (in its window prefab) -> text binding.",
+    "materialKeywords": {
       "type": "object",
       "additionalProperties": {
-        "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/text" }
+        "type": "array",
+        "items": {
+          "type": "string",
+          "minLength": 1
+        }
       }
     },
-    "frameTexts": {
-      "description": "Open fonts: frame name (frames.json frames) -> text node path (in its frame prefab) -> text binding.",
+    "texts": {
       "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      },
       "additionalProperties": {
-        "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/text" }
+        "$ref": "#/$defs/text"
       }
     },
     "spriteAssets": {
       "description": "Sprite asset name -> TextMeshPro sprite asset reduced to the sprites the episode's texts can draw.",
-      "type": "object", "propertyNames": { "minLength": 1 }, "additionalProperties": { "$ref": "#/$defs/spriteAsset" }
+      "type": "object",
+      "propertyNames": {
+        "minLength": 1
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/spriteAsset"
+      }
     },
     "emojiSpriteAsset": {
       "description": "With spriteAssets: the key of the sprite asset LocalizeManager.EmojiSpriteAsset is.",
-      "type": "string", "minLength": 1
+      "type": "string",
+      "minLength": 1
     },
     "coverage": {
       "type": "object",
-      "required": ["characters", "missing"],
+      "required": [
+        "characters",
+        "missing"
+      ],
       "properties": {
-        "characters": { "type": "integer", "minimum": 0 },
-        "missing": { "type": "array", "items": { "type": "string", "minLength": 1 } },
-        "missingGlyph": { "type": "array", "items": { "type": "string", "minLength": 1 } },
+        "characters": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "missing": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "missingGlyph": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
         "sprites": {
           "type": "object",
-          "required": ["characters", "missing"],
+          "required": [
+            "characters",
+            "missing"
+          ],
           "properties": {
-            "characters": { "type": "integer", "minimum": 0 },
-            "missing": { "type": "array", "items": { "type": "string" } }
+            "characters": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "missing": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
           }
         },
         "underline": {
           "type": "object",
-          "required": ["font", "character", "inAsset"],
+          "required": [
+            "font",
+            "character",
+            "inAsset"
+          ],
           "properties": {
-            "font": { "type": "string", "minLength": 1 },
-            "character": { "const": "_" },
-            "inAsset": { "type": "boolean" }
+            "font": {
+              "type": "string",
+              "minLength": 1
+            },
+            "character": {
+              "const": "_"
+            },
+            "inAsset": {
+              "type": "boolean"
+            }
           }
         }
       }
     },
-    "tmpSettings": { "type": "object" },
     "lineBreaking": {
       "type": "object",
-      "required": ["leading", "following", "useModernHangulLineBreakingRules"],
+      "required": [
+        "leading",
+        "following",
+        "useModernHangulLineBreakingRules"
+      ],
       "properties": {
-        "leading": { "type": "string" },
-        "following": { "type": "string" },
-        "useModernHangulLineBreakingRules": { "type": "boolean" }
+        "leading": {
+          "type": "string"
+        },
+        "following": {
+          "type": "string"
+        },
+        "useModernHangulLineBreakingRules": {
+          "type": "boolean"
+        }
+      }
+    },
+    "shaders": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "sprites": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": [
+          "spriteAsset"
+        ],
+        "properties": {
+          "spriteAsset": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
       }
     }
   },
   "$defs": {
-    "int": { "type": "integer" },
-    "num": { "type": "number" },
+    "int": {
+      "type": "integer"
+    },
+    "num": {
+      "type": "number"
+    },
     "faceInfo": {
       "type": "object",
-      "required": ["m_PointSize", "m_Scale", "m_UnitsPerEM", "m_LineHeight", "m_AscentLine", "m_CapLine", "m_MeanLine",
-                   "m_Baseline", "m_DescentLine", "m_SuperscriptOffset", "m_SuperscriptSize", "m_SubscriptOffset",
-                   "m_SubscriptSize", "m_UnderlineOffset", "m_UnderlineThickness", "m_StrikethroughOffset",
-                   "m_StrikethroughThickness", "m_TabWidth"],
+      "required": [
+        "m_PointSize",
+        "m_Scale",
+        "m_UnitsPerEM",
+        "m_LineHeight",
+        "m_AscentLine",
+        "m_CapLine",
+        "m_MeanLine",
+        "m_Baseline",
+        "m_DescentLine",
+        "m_SuperscriptOffset",
+        "m_SuperscriptSize",
+        "m_SubscriptOffset",
+        "m_SubscriptSize",
+        "m_UnderlineOffset",
+        "m_UnderlineThickness",
+        "m_StrikethroughOffset",
+        "m_StrikethroughThickness",
+        "m_TabWidth"
+      ],
       "properties": {
-        "m_FaceIndex": { "type": "integer", "minimum": 0 },
-        "m_FamilyName": { "type": "string" },
-        "m_StyleName": { "type": "string" },
-        "m_PointSize": { "type": "number", "exclusiveMinimum": 0 },
-        "m_Scale": { "type": "number", "exclusiveMinimum": 0 },
-        "m_UnitsPerEM": { "type": "integer", "minimum": 1 },
-        "m_LineHeight": { "$ref": "#/$defs/num" },
-        "m_AscentLine": { "$ref": "#/$defs/num" },
-        "m_CapLine": { "$ref": "#/$defs/num" },
-        "m_MeanLine": { "$ref": "#/$defs/num" },
-        "m_Baseline": { "$ref": "#/$defs/num" },
-        "m_DescentLine": { "$ref": "#/$defs/num" },
-        "m_SuperscriptOffset": { "$ref": "#/$defs/num" },
-        "m_SuperscriptSize": { "$ref": "#/$defs/num" },
-        "m_SubscriptOffset": { "$ref": "#/$defs/num" },
-        "m_SubscriptSize": { "$ref": "#/$defs/num" },
-        "m_UnderlineOffset": { "$ref": "#/$defs/num" },
-        "m_UnderlineThickness": { "$ref": "#/$defs/num" },
-        "m_StrikethroughOffset": { "$ref": "#/$defs/num" },
-        "m_StrikethroughThickness": { "$ref": "#/$defs/num" },
-        "m_TabWidth": { "$ref": "#/$defs/num" }
+        "m_FaceIndex": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "m_FamilyName": {
+          "type": "string"
+        },
+        "m_StyleName": {
+          "type": "string"
+        },
+        "m_PointSize": {
+          "type": "number",
+          "exclusiveMinimum": 0
+        },
+        "m_Scale": {
+          "type": "number",
+          "exclusiveMinimum": 0
+        },
+        "m_UnitsPerEM": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "m_LineHeight": {
+          "$ref": "#/$defs/num"
+        },
+        "m_AscentLine": {
+          "$ref": "#/$defs/num"
+        },
+        "m_CapLine": {
+          "$ref": "#/$defs/num"
+        },
+        "m_MeanLine": {
+          "$ref": "#/$defs/num"
+        },
+        "m_Baseline": {
+          "$ref": "#/$defs/num"
+        },
+        "m_DescentLine": {
+          "$ref": "#/$defs/num"
+        },
+        "m_SuperscriptOffset": {
+          "$ref": "#/$defs/num"
+        },
+        "m_SuperscriptSize": {
+          "$ref": "#/$defs/num"
+        },
+        "m_SubscriptOffset": {
+          "$ref": "#/$defs/num"
+        },
+        "m_SubscriptSize": {
+          "$ref": "#/$defs/num"
+        },
+        "m_UnderlineOffset": {
+          "$ref": "#/$defs/num"
+        },
+        "m_UnderlineThickness": {
+          "$ref": "#/$defs/num"
+        },
+        "m_StrikethroughOffset": {
+          "$ref": "#/$defs/num"
+        },
+        "m_StrikethroughThickness": {
+          "$ref": "#/$defs/num"
+        },
+        "m_TabWidth": {
+          "$ref": "#/$defs/num"
+        }
       }
     },
     "metrics": {
       "type": "object",
-      "required": ["m_Width", "m_Height", "m_HorizontalBearingX", "m_HorizontalBearingY", "m_HorizontalAdvance"],
+      "required": [
+        "m_Width",
+        "m_Height",
+        "m_HorizontalBearingX",
+        "m_HorizontalBearingY",
+        "m_HorizontalAdvance"
+      ],
       "properties": {
-        "m_Width": { "type": "number", "minimum": 0 },
-        "m_Height": { "type": "number", "minimum": 0 },
-        "m_HorizontalBearingX": { "$ref": "#/$defs/num" },
-        "m_HorizontalBearingY": { "$ref": "#/$defs/num" },
-        "m_HorizontalAdvance": { "$ref": "#/$defs/num" }
+        "m_Width": {
+          "type": "number",
+          "minimum": 0
+        },
+        "m_Height": {
+          "type": "number",
+          "minimum": 0
+        },
+        "m_HorizontalBearingX": {
+          "$ref": "#/$defs/num"
+        },
+        "m_HorizontalBearingY": {
+          "$ref": "#/$defs/num"
+        },
+        "m_HorizontalAdvance": {
+          "$ref": "#/$defs/num"
+        }
       }
     },
     "rect": {
       "type": "object",
-      "required": ["m_X", "m_Y", "m_Width", "m_Height"],
+      "required": [
+        "m_X",
+        "m_Y",
+        "m_Width",
+        "m_Height"
+      ],
       "properties": {
-        "m_X": { "$ref": "#/$defs/int" },
-        "m_Y": { "$ref": "#/$defs/int" },
-        "m_Width": { "type": "integer", "minimum": 0 },
-        "m_Height": { "type": "integer", "minimum": 0 }
+        "m_X": {
+          "$ref": "#/$defs/int"
+        },
+        "m_Y": {
+          "$ref": "#/$defs/int"
+        },
+        "m_Width": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "m_Height": {
+          "type": "integer",
+          "minimum": 0
+        }
       }
     },
     "glyph": {
       "type": "object",
-      "required": ["metrics", "rect", "scale", "atlasIndex"],
+      "required": [
+        "metrics",
+        "rect",
+        "scale",
+        "atlasIndex"
+      ],
       "properties": {
-        "metrics": { "$ref": "#/$defs/metrics" },
-        "rect": { "$ref": "#/$defs/rect" },
-        "scale": { "type": "number", "exclusiveMinimum": 0 },
-        "atlasIndex": { "type": ["integer", "null"], "minimum": 0 },
+        "metrics": {
+          "$ref": "#/$defs/metrics"
+        },
+        "rect": {
+          "$ref": "#/$defs/rect"
+        },
+        "scale": {
+          "type": "number",
+          "exclusiveMinimum": 0
+        },
+        "atlasIndex": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0
+        },
         "packed": {
           "type": "object",
-          "required": ["texture", "dx", "dy"],
+          "required": [
+            "texture",
+            "dx",
+            "dy"
+          ],
           "additionalProperties": false,
           "properties": {
-            "texture": { "type": "string", "minLength": 1 },
-            "dx": { "$ref": "#/$defs/int" },
-            "dy": { "$ref": "#/$defs/int" }
+            "texture": {
+              "type": "string",
+              "minLength": 1
+            },
+            "dx": {
+              "$ref": "#/$defs/int"
+            },
+            "dy": {
+              "$ref": "#/$defs/int"
+            }
           }
         },
-        "runtime": { "type": "boolean" }
+        "runtime": {
+          "type": "boolean"
+        }
       }
     },
     "character": {
       "type": "object",
-      "required": ["glyph", "scale", "elementType"],
+      "required": [
+        "glyph",
+        "scale",
+        "elementType"
+      ],
       "properties": {
-        "glyph": { "type": "integer", "minimum": 0 },
-        "scale": { "type": "number", "exclusiveMinimum": 0 },
-        "elementType": { "type": "integer" }
+        "glyph": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "scale": {
+          "type": "number",
+          "exclusiveMinimum": 0
+        },
+        "elementType": {
+          "type": "integer"
+        }
       }
     },
     "valueRecord": {
       "type": "object",
-      "required": ["xPlacement", "yPlacement", "xAdvance", "yAdvance"],
+      "required": [
+        "xPlacement",
+        "yPlacement",
+        "xAdvance",
+        "yAdvance"
+      ],
       "properties": {
-        "xPlacement": { "$ref": "#/$defs/num" },
-        "yPlacement": { "$ref": "#/$defs/num" },
-        "xAdvance": { "$ref": "#/$defs/num" },
-        "yAdvance": { "$ref": "#/$defs/num" }
+        "xPlacement": {
+          "$ref": "#/$defs/num"
+        },
+        "yPlacement": {
+          "$ref": "#/$defs/num"
+        },
+        "xAdvance": {
+          "$ref": "#/$defs/num"
+        },
+        "yAdvance": {
+          "$ref": "#/$defs/num"
+        }
       }
     },
     "source": {
       "type": "object",
-      "required": ["family", "style", "version", "license", "file", "faceIndex", "bytes", "sha256", "generator"],
+      "required": [
+        "family",
+        "style",
+        "version",
+        "license",
+        "file",
+        "faceIndex",
+        "bytes",
+        "sha256",
+        "generator"
+      ],
       "properties": {
-        "family": { "type": "string" },
-        "style": { "type": "string" },
-        "version": { "type": "string" },
-        "license": { "type": "string" },
-        "file": { "type": "string", "pattern": "^[^/\\\\]+$" },
-        "faceIndex": { "type": "integer", "minimum": 0 },
-        "bytes": { "type": "integer", "minimum": 1 },
-        "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
-        "generator": { "type": "object" }
+        "family": {
+          "type": "string"
+        },
+        "style": {
+          "type": "string"
+        },
+        "version": {
+          "type": "string"
+        },
+        "license": {
+          "type": "string"
+        },
+        "file": {
+          "type": "string",
+          "pattern": "^[^/\\\\]+$"
+        },
+        "faceIndex": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "bytes": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "sha256": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{64}$"
+        },
+        "generator": {
+          "type": "object"
+        }
       }
     },
     "font": {
       "type": "object",
-      "required": ["faceInfo", "atlasWidth", "atlasHeight", "atlasPadding", "atlasRenderMode", "atlasPopulationMode",
-                   "atlases", "normalStyle", "normalSpacingOffset", "boldStyle", "boldSpacing", "italicStyle", "tabSize",
-                   "material", "fallbacks", "glyphPairAdjustmentRecords", "characters", "glyphs",
-                   "runtimeCharacters", "runtimeGlyphs", "subset"],
+      "required": [
+        "faceInfo",
+        "atlasWidth",
+        "atlasHeight",
+        "atlasPadding",
+        "atlasRenderMode",
+        "atlasPopulationMode",
+        "atlases",
+        "normalStyle",
+        "normalSpacingOffset",
+        "boldStyle",
+        "boldSpacing",
+        "italicStyle",
+        "tabSize",
+        "material",
+        "fallbacks",
+        "glyphPairAdjustmentRecords",
+        "characters",
+        "glyphs",
+        "runtimeCharacters",
+        "runtimeGlyphs",
+        "subset"
+      ],
       "properties": {
-        "faceInfo": { "$ref": "#/$defs/faceInfo" },
-        "atlasWidth": { "type": "integer", "minimum": 1 },
-        "atlasHeight": { "type": "integer", "minimum": 1 },
-        "atlasPadding": { "type": "integer", "minimum": 0 },
-        "atlasRenderMode": { "$ref": "#/$defs/int" },
-        "atlasPopulationMode": { "enum": [0, 1] },
-        "atlases": { "type": "array", "items": { "type": ["string", "null"] } },
-        "normalStyle": { "$ref": "#/$defs/num" },
-        "normalSpacingOffset": { "$ref": "#/$defs/num" },
-        "boldStyle": { "$ref": "#/$defs/num" },
-        "boldSpacing": { "$ref": "#/$defs/num" },
-        "italicStyle": { "$ref": "#/$defs/int" },
-        "tabSize": { "$ref": "#/$defs/int" },
-        "material": { "type": "string", "minLength": 1 },
-        "fallbacks": { "type": "array", "items": { "type": "string", "minLength": 1 } },
-        "glyphPairAdjustmentRecords": { "type": "integer", "minimum": 0 },
+        "faceInfo": {
+          "$ref": "#/$defs/faceInfo"
+        },
+        "atlasWidth": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "atlasHeight": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "atlasPadding": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "atlasRenderMode": {
+          "$ref": "#/$defs/int"
+        },
+        "atlasPopulationMode": {
+          "enum": [
+            0,
+            1
+          ]
+        },
+        "atlases": {
+          "type": "array",
+          "items": {
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "normalStyle": {
+          "$ref": "#/$defs/num"
+        },
+        "normalSpacingOffset": {
+          "$ref": "#/$defs/num"
+        },
+        "boldStyle": {
+          "$ref": "#/$defs/num"
+        },
+        "boldSpacing": {
+          "$ref": "#/$defs/num"
+        },
+        "italicStyle": {
+          "$ref": "#/$defs/int"
+        },
+        "tabSize": {
+          "$ref": "#/$defs/int"
+        },
+        "material": {
+          "type": "string",
+          "minLength": 1
+        },
+        "fallbacks": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "glyphPairAdjustmentRecords": {
+          "type": "integer",
+          "minimum": 0
+        },
         "glyphPairAdjustments": {
           "type": "object",
-          "propertyNames": { "pattern": "^[0-9]+$" },
+          "propertyNames": {
+            "pattern": "^[0-9]+$"
+          },
           "additionalProperties": {
             "type": "object",
-            "required": ["first", "second", "flags"],
+            "required": [
+              "first",
+              "second",
+              "flags"
+            ],
             "properties": {
-              "first": { "$ref": "#/$defs/valueRecord" },
-              "second": { "$ref": "#/$defs/valueRecord" },
-              "flags": { "$ref": "#/$defs/int" }
+              "first": {
+                "$ref": "#/$defs/valueRecord"
+              },
+              "second": {
+                "$ref": "#/$defs/valueRecord"
+              },
+              "flags": {
+                "$ref": "#/$defs/int"
+              }
             }
           }
         },
         "characters": {
           "type": "object",
-          "propertyNames": { "pattern": "^[0-9]+$" },
-          "additionalProperties": { "$ref": "#/$defs/character" }
+          "propertyNames": {
+            "pattern": "^[0-9]+$"
+          },
+          "additionalProperties": {
+            "$ref": "#/$defs/character"
+          }
         },
         "missingGlyph": {
           "description": "The code points the game's font asset lacks with its fallbacks (ascending) and the character TextMeshPro draws for them.",
           "type": "object",
-          "required": ["unicode", "characters"],
+          "required": [
+            "unicode",
+            "characters"
+          ],
           "additionalProperties": false,
           "properties": {
-            "unicode": { "type": "integer", "minimum": 0 },
-            "characters": { "type": "array", "minItems": 1, "items": { "type": "integer", "minimum": 0 } }
+            "unicode": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "characters": {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "type": "integer",
+                "minimum": 0
+              }
+            }
           }
         },
         "glyphs": {
           "type": "object",
-          "propertyNames": { "pattern": "^[0-9]+$" },
-          "additionalProperties": { "$ref": "#/$defs/glyph" }
+          "propertyNames": {
+            "pattern": "^[0-9]+$"
+          },
+          "additionalProperties": {
+            "$ref": "#/$defs/glyph"
+          }
+        },
+        "runtimeCharacters": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "minimum": 0
+          }
+        },
+        "runtimeGlyphs": {
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "sourceFont": {
+          "type": [
+            "object",
+            "null"
+          ]
+        },
+        "source": {
+          "$ref": "#/$defs/source"
         },
-        "runtimeCharacters": { "type": "array", "items": { "type": "integer", "minimum": 0 } },
-        "runtimeGlyphs": { "type": ["object", "null"] },
-        "sourceFont": { "type": ["object", "null"] },
-        "source": { "$ref": "#/$defs/source" },
         "browser": {
           "description": "The glyphs are drawn by the browser: characters and glyphs are made when a text first uses a character (the point size, atlasPadding and atlasRenderMode of the font asset give the SDF), on one page of pageWidth x pageHeight texels (2048 x 2048 by default), and the lists above start empty.",
           "type": "object",
-          "required": ["family"],
+          "required": [
+            "family"
+          ],
           "additionalProperties": false,
           "properties": {
-            "family": { "type": "string", "minLength": 1 },
-            "weight": { "type": "string", "minLength": 1 },
-            "style": { "type": "string", "minLength": 1 },
-            "pageWidth": { "type": "integer", "minimum": 1 },
-            "pageHeight": { "type": "integer", "minimum": 1 },
-            "underlayOffset": { "type": "number", "minimum": 0 },
-            "gameFont": { "type": "string", "minLength": 1 }
+            "family": {
+              "type": "string",
+              "minLength": 1
+            },
+            "weight": {
+              "type": "string",
+              "minLength": 1
+            },
+            "style": {
+              "type": "string",
+              "minLength": 1
+            },
+            "pageWidth": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "pageHeight": {
+              "type": "integer",
+              "minimum": 1
+            },
+            "underlayOffset": {
+              "type": "number",
+              "minimum": 0
+            },
+            "gameFont": {
+              "type": "string",
+              "minLength": 1
+            }
           }
         },
-        "subset": { "type": "string" }
+        "subset": {
+          "type": "string"
+        }
       }
     },
     "spriteAsset": {
       "type": "object",
-      "required": ["faceInfo", "characters", "glyphs", "sequences", "material"],
+      "required": [
+        "faceInfo",
+        "characters",
+        "glyphs",
+        "sequences",
+        "material"
+      ],
       "properties": {
         "faceInfo": {
           "type": "object",
-          "required": ["m_PointSize", "m_Scale", "m_Baseline", "m_AscentLine", "m_DescentLine"],
+          "required": [
+            "m_PointSize",
+            "m_Scale",
+            "m_Baseline",
+            "m_AscentLine",
+            "m_DescentLine"
+          ],
           "properties": {
-            "m_PointSize": { "type": "number", "minimum": 0 },
-            "m_Scale": { "$ref": "#/$defs/num" },
-            "m_Baseline": { "$ref": "#/$defs/num" },
-            "m_AscentLine": { "$ref": "#/$defs/num" },
-            "m_DescentLine": { "$ref": "#/$defs/num" }
+            "m_PointSize": {
+              "type": "number",
+              "minimum": 0
+            },
+            "m_Scale": {
+              "$ref": "#/$defs/num"
+            },
+            "m_Baseline": {
+              "$ref": "#/$defs/num"
+            },
+            "m_AscentLine": {
+              "$ref": "#/$defs/num"
+            },
+            "m_DescentLine": {
+              "$ref": "#/$defs/num"
+            }
           }
         },
         "characters": {
           "type": "array",
           "items": {
             "type": "object",
-            "required": ["index", "unicode", "name", "glyph", "scale"],
+            "required": [
+              "index",
+              "unicode",
+              "name",
+              "glyph",
+              "scale"
+            ],
             "properties": {
-              "index": { "type": "integer", "minimum": 0 },
-              "unicode": { "type": "integer", "minimum": 0 },
-              "name": { "type": "string" },
-              "glyph": { "type": "integer", "minimum": 0 },
-              "scale": { "$ref": "#/$defs/num" }
+              "index": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "unicode": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "name": {
+                "type": "string"
+              },
+              "glyph": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "scale": {
+                "$ref": "#/$defs/num"
+              }
             }
           }
         },
         "glyphs": {
           "type": "object",
-          "propertyNames": { "pattern": "^[0-9]+$" },
-          "additionalProperties": { "$ref": "#/$defs/glyph" }
+          "propertyNames": {
+            "pattern": "^[0-9]+$"
+          },
+          "additionalProperties": {
+            "$ref": "#/$defs/glyph"
+          }
         },
         "sequences": {
           "type": "array",
           "items": {
             "type": "object",
-            "required": ["name", "unicode"],
+            "required": [
+              "name",
+              "unicode"
+            ],
             "properties": {
-              "name": { "type": "string", "pattern": "-" },
-              "unicode": { "type": "integer", "minimum": 0 }
+              "name": {
+                "type": "string",
+                "pattern": "-"
+              },
+              "unicode": {
+                "type": "integer",
+                "minimum": 0
+              }
             }
           }
         },
-        "material": { "type": "string", "minLength": 1 },
-        "source": { "anyOf": [{ "$ref": "#/$defs/source" }, { "type": "null" }] },
-        "subset": { "type": "string" }
+        "material": {
+          "type": "string",
+          "minLength": 1
+        },
+        "source": {
+          "anyOf": [
+            {
+              "$ref": "#/$defs/source"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "subset": {
+          "type": "string"
+        }
       }
     },
     "texture": {
       "type": "object",
-      "required": ["texture", "name", "width", "height", "mipCount", "settings"],
+      "required": [
+        "texture",
+        "name",
+        "width",
+        "height",
+        "mipCount",
+        "settings"
+      ],
       "properties": {
-        "texture": { "type": "string", "pattern": "^fonts/[^/\\\\]+\\.png$" },
-        "name": { "type": "string", "minLength": 1 },
-        "width": { "type": "integer", "minimum": 1 },
-        "height": { "type": "integer", "minimum": 1 },
-        "mipCount": { "const": 1 },
+        "texture": {
+          "type": "string",
+          "pattern": "^(fonts|textures)/[^/\\\\]+\\.png$"
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "width": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "height": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "mipCount": {
+          "const": 1
+        },
         "settings": {
           "type": "object",
-          "required": ["m_FilterMode", "m_WrapU", "m_WrapV"],
+          "required": [
+            "m_FilterMode",
+            "m_WrapU",
+            "m_WrapV"
+          ],
           "properties": {
-            "m_FilterMode": { "enum": [0, 1, 2] },
-            "m_WrapU": { "enum": [0, 1, 2] },
-            "m_WrapV": { "enum": [0, 1, 2] }
+            "m_FilterMode": {
+              "enum": [
+                0,
+                1,
+                2
+              ]
+            },
+            "m_WrapU": {
+              "enum": [
+                0,
+                1,
+                2
+              ]
+            },
+            "m_WrapV": {
+              "enum": [
+                0,
+                1,
+                2
+              ]
+            }
           }
         }
       }
     },
     "material": {
       "type": "object",
-      "required": ["material", "shader", "keywords", "textures", "floats", "colors"],
+      "required": [
+        "material",
+        "shader",
+        "keywords",
+        "textures",
+        "floats",
+        "colors"
+      ],
       "properties": {
-        "material": { "type": "string", "minLength": 1 },
+        "material": {
+          "type": "string",
+          "minLength": 1
+        },
         "shader": {
           "type": "object",
-          "required": ["shader"],
-          "properties": { "shader": { "type": "string", "minLength": 1 } }
-        },
-        "keywords": { "type": "array", "items": { "type": "string" } },
-        "textures": { "type": "object" },
-        "floats": { "type": "object", "additionalProperties": { "type": "number" } },
-        "ints": { "type": "object", "additionalProperties": { "type": "number" } },
-        "colors": { "type": "object" }
+          "required": [
+            "shader"
+          ],
+          "properties": {
+            "shader": {
+              "type": "string",
+              "minLength": 1
+            }
+          }
+        },
+        "keywords": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "textures": {
+          "type": "object"
+        },
+        "floats": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "number"
+          }
+        },
+        "ints": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "number"
+          }
+        },
+        "colors": {
+          "type": "object"
+        }
       }
     },
     "text": {
       "type": "object",
-      "required": ["class", "enabled", "fontAsset", "material", "localized", "m_fontSize", "m_text"],
+      "required": [
+        "font",
+        "localized",
+        "style"
+      ],
       "properties": {
-        "class": { "enum": ["TextMeshProUGUI", "RubyTextMeshProUGUI", "RubyEmojiTextMeshProUGUI"] },
-        "enabled": { "type": ["boolean", "integer"] },
-        "fontAsset": { "type": "string", "minLength": 1 },
-        "material": { "type": "string", "minLength": 1 },
-        "localized": {
+        "font": {
           "type": "object",
-          "required": ["fontAsset", "material", "lineSpacing"],
+          "required": [
+            "fontAsset",
+            "material",
+            "lineSpacing"
+          ],
           "properties": {
-            "fontAsset": { "type": "string", "minLength": 1 },
-            "material": { "type": "string", "minLength": 1 },
-            "lineSpacing": { "type": "number" }
+            "fontAsset": {
+              "type": "string",
+              "minLength": 1
+            },
+            "material": {
+              "type": "string",
+              "minLength": 1
+            },
+            "lineSpacing": {
+              "type": "number"
+            }
           }
         },
-        "m_fontSize": { "type": "number" },
-        "m_text": { "type": "string" },
-        "m_monospaceDistEm": { "type": "number" },
-        "spriteAsset": { "type": "string", "minLength": 1 },
-        "m_tintAllSprites": { "type": ["integer", "boolean"] },
-        "ruby": {
+        "localized": {
           "type": "object",
-          "required": ["_rubyVerticalOffset", "_rubyScale", "_rubyLineHeight", "_rubyShowType", "_rubyMargin"],
+          "required": [
+            "fontAsset",
+            "material",
+            "lineSpacing"
+          ],
           "properties": {
-            "_rubyVerticalOffset": { "type": "string" },
-            "_rubyScale": { "type": "number" },
-            "_rubyLineHeight": { "type": "string" },
-            "_rubyShowType": { "type": "integer" },
-            "_rubyMargin": { "type": "number" }
+            "fontAsset": {
+              "type": "string",
+              "minLength": 1
+            },
+            "material": {
+              "type": "string",
+              "minLength": 1
+            },
+            "lineSpacing": {
+              "type": "number"
+            }
           }
         },
-        "uiRubyText": {
-          "type": "object",
-          "required": ["_rubyMarginTop"],
-          "properties": { "_rubyMarginTop": { "type": "number" } }
+        "style": {
+          "type": "object"
         },
         "localizeKoreanAdjust": {
-          "type": "object",
-          "required": ["_koreanFontStyle", "m_Enabled"],
-          "properties": { "_koreanFontStyle": { "type": "integer" }, "m_Enabled": { "type": "boolean" } }
+          "type": "object"
         }
       }
     }
diff --git a/schema/story-host.schema.json b/schema/story-host.schema.json
new file mode 100644
index 0000000..235f57e
--- /dev/null
+++ b/schema/story-host.schema.json
@@ -0,0 +1,185 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-host.schema.json",
+  "title": "Story host objects",
+  "required": [
+    "format",
+    "kind",
+    "cameraTarget",
+    "dotween",
+    "prefabs",
+    "overlayRoot",
+    "layoutRoot",
+    "openedSequences",
+    "home",
+    "afterlive",
+    "graphics",
+    "bindings",
+    "shaders"
+  ],
+  "properties": {
+    "format": {
+      "const": "nnnotes.story-host/1"
+    },
+    "kind": {
+      "enum": [
+        "home",
+        "afterlive"
+      ]
+    },
+    "cameraTarget": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "dotween": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "prefabs": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "overlayRoot": {
+      "type": "object",
+      "required": [
+        "prefab",
+        "path"
+      ],
+      "properties": {
+        "prefab": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "path": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "layoutRoot": {
+      "type": "object",
+      "required": [
+        "prefab",
+        "path",
+        "fields"
+      ],
+      "properties": {
+        "prefab": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "path": {
+          "type": "string",
+          "minLength": 1
+        },
+        "fields": {
+          "type": "object"
+        }
+      }
+    },
+    "openedSequences": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "prefab",
+          "path"
+        ],
+        "properties": {
+          "prefab": {
+            "type": "string",
+            "pattern": "^.+:-?[0-9]+$"
+          },
+          "path": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      }
+    },
+    "home": {
+      "type": [
+        "object",
+        "null"
+      ]
+    },
+    "afterlive": {
+      "type": [
+        "object",
+        "null"
+      ]
+    },
+    "graphics": {
+      "type": "object",
+      "required": [
+        "graphics"
+      ],
+      "properties": {
+        "graphics": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "player": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "quality": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "path",
+                "attribute"
+              ],
+              "properties": {
+                "path": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "attribute": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          },
+          "propertyNames": {
+            "type": "string",
+            "pattern": "^.+:-?[0-9]+$"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "shaders": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    }
+  }
+}
diff --git a/schema/story-language.schema.json b/schema/story-language.schema.json
index dbff26e..6d61574 100644
--- a/schema/story-language.schema.json
+++ b/schema/story-language.schema.json
@@ -1,31 +1,71 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-language.schema.json",
-  "title": "Story language settings (ui/languages.json)",
-  "description": "The settings of one language of a story: LanguageMode, text field, the line spacing of localized texts and the font asset and line metrics of each font role. See docs/story-data-format.md.",
   "type": "object",
-  "required": ["format", "language", "mode", "field", "lineSpacing", "fonts", "roles"],
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-language.schema.json",
+  "title": "Story UI language settings",
+  "required": [
+    "code",
+    "mode",
+    "field",
+    "lineSpacing",
+    "fontNames",
+    "additionalFontNames",
+    "materialTypes",
+    "fontSwap"
+  ],
   "properties": {
-    "format": { "const": "ournotes.story-language/1" },
-    "language": { "enum": ["ja", "en", "zh-Hant", "zh-Hans", "ko"] },
-    "mode": { "enum": [0, 1, 2, 3, 4] },
-    "field": { "enum": ["japanese", "english", "traditionalChinese", "simplifiedChinese", "korean"] },
-    "lineSpacing": { "type": "number" },
-    "fonts": { "enum": ["open", "game"] },
-    "roles": {
+    "code": {
+      "enum": [
+        "ja",
+        "en",
+        "zh-Hant",
+        "zh-Hans",
+        "ko"
+      ]
+    },
+    "mode": {
+      "enum": [
+        0,
+        1,
+        2,
+        3,
+        4
+      ]
+    },
+    "field": {
+      "enum": [
+        "japanese",
+        "english",
+        "traditionalChinese",
+        "simplifiedChinese",
+        "korean"
+      ]
+    },
+    "lineSpacing": {
+      "type": "number"
+    },
+    "fontNames": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "additionalFontNames": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "materialTypes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "fontSwap": {
       "type": "object",
-      "propertyNames": { "pattern": "^[a-z][A-Za-z0-9]*$" },
       "additionalProperties": {
-        "type": "object",
-        "required": ["fontAsset", "lineHeightEm", "ascentEm", "descentEm", "spacingOffset", "boldSpacing"],
-        "properties": {
-          "fontAsset": { "type": "string", "minLength": 1 },
-          "lineHeightEm": { "type": "number" },
-          "ascentEm": { "type": "number" },
-          "descentEm": { "type": "number" },
-          "spacingOffset": { "type": "number" },
-          "boldSpacing": { "type": "number" }
-        }
+        "type": "string"
       }
     }
   }
diff --git a/schema/story-manifest.schema.json b/schema/story-manifest.schema.json
index 884fe6c..aa77103 100644
--- a/schema/story-manifest.schema.json
+++ b/schema/story-manifest.schema.json
@@ -1,142 +1,146 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-manifest.schema.json",
-  "title": "Story manifest (stories/<advId>.json, or stories/<region>/<advId>.json)",
-  "description": "The logical files of one story (common files and one group per language) and where their bytes are; the file entries are those of a chart manifest. See docs/story-data-format.md.",
+  "title": "Story product manifest",
+  "description": "A story product and the files of its episode and part index.",
   "type": "object",
-  "required": ["format", "advId", "root", "models", "story", "language", "audio", "audioFormat", "fonts", "requires", "files", "languages"],
+  "required": [
+    "schema",
+    "product",
+    "subject",
+    "files",
+    "objects"
+  ],
+  "additionalProperties": false,
   "properties": {
-    "format": { "const": "ournotes.story-manifest/2" },
-    "advId": { "type": "integer", "minimum": 1 },
-    "root": {
-      "description": "The site root relative to the manifest: \"../\" for stories/<advId>.json, \"../../\" for stories/<region>/<advId>.json.",
-      "type": "string",
-      "pattern": "^(\\.\\./)+$"
+    "schema": {
+      "const": "nnnotes.product/1"
     },
-    "models": {
-      "description": "Model id -> the path of its model manifest (a product manifest of live2d.model) relative to the site root (models/<id>.json), keys sorted: the Live2D models the story's Character rows use.",
-      "type": "object",
-      "propertyNames": { "pattern": "^[a-z0-9_]+$" },
-      "additionalProperties": { "type": "string", "pattern": "^models/[a-z0-9_]+\\.json$" }
+    "product": {
+      "const": "story"
     },
-    "story": { "$ref": "#/$defs/facts" },
-    "regions": { "type": "array", "items": { "type": "string", "pattern": "^[a-z0-9_-]+$" }, "minItems": 1 },
-    "language": { "$ref": "#/$defs/language" },
-    "audio": { "type": "boolean" },
-    "audioFormat": { "enum": ["aac", "flac", null] },
-    "fonts": { "enum": ["open", "game"] },
-    "requires": {
-      "type": "object",
-      "required": ["commands", "cubismCore", "motionSync"],
-      "properties": {
-        "commands": { "type": "array", "items": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9]*$" } },
-        "cubismCore": { "type": "boolean" },
-        "motionSync": { "type": "boolean" }
-      }
+    "subject": {
+      "type": "string",
+      "pattern": "^[0-9]+$"
     },
-    "files": { "$ref": "#/$defs/files" },
-    "host": {
+    "files": {
+      "description": "The product's own files by logical path.",
       "type": "object",
-      "required": ["kind", "doc", "ui"],
-      "additionalProperties": false,
-      "properties": {
-        "kind": { "enum": ["home", "afterlive"] },
-        "doc": { "const": "host/host.json" },
-        "ui": { "const": "ui/simple/ui.json" }
+      "propertyNames": {
+        "pattern": "^[A-Za-z0-9_][^\\\\]*$"
+      },
+      "additionalProperties": {
+        "$ref": "#/$defs/file"
       }
     },
-    "languages": {
+    "objects": {
+      "description": "Object id (<serialized file>:<path id>) -> the object's class, name and files by role (json, image, index, program:<platform>/<name>, blob:<field>).",
       "type": "object",
-      "propertyNames": { "$ref": "#/$defs/language" },
+      "propertyNames": {
+        "pattern": "^.+:-?[0-9]+$"
+      },
       "additionalProperties": {
         "type": "object",
-        "required": ["files"],
+        "required": [
+          "class",
+          "files"
+        ],
         "additionalProperties": false,
-        "properties": { "files": { "$ref": "#/$defs/files" } }
+        "properties": {
+          "class": {
+            "type": "string",
+            "minLength": 1
+          },
+          "name": {
+            "type": "string"
+          },
+          "files": {
+            "type": "object",
+            "additionalProperties": {
+              "$ref": "#/$defs/file"
+            }
+          }
+        }
       }
+    },
+    "root": {
+      "type": "string",
+      "minLength": 1
+    },
+    "language": {
+      "enum": [
+        "ja",
+        "en",
+        "zh-Hant",
+        "zh-Hans",
+        "ko"
+      ]
     }
   },
   "$defs": {
-    "language": { "enum": ["ja", "en", "zh-Hant", "zh-Hans", "ko"] },
-    "names": {
-      "type": "object",
-      "propertyNames": { "$ref": "#/$defs/language" },
-      "additionalProperties": { "type": "string", "minLength": 1 }
-    },
-    "facts": {
-      "type": "object",
-      "required": ["advId", "asset", "playbackMode", "titles", "groups", "commands", "commandCount", "language", "languages"],
-      "properties": {
-        "advId": { "type": "integer", "minimum": 1 },
-        "asset": { "type": "string", "minLength": 1 },
-        "sheetName": { "type": "string" },
-        "playbackMode": { "enum": [0, 1] },
-        "titles": { "$ref": "#/$defs/names" },
-        "groups": { "type": "array", "items": { "type": "object", "required": ["kind", "id", "characters"] } },
-        "commands": { "type": "array", "items": { "type": "string", "pattern": "^[A-Za-z][A-Za-z0-9]*$" } },
-        "commandCount": { "type": "integer", "minimum": 0 },
-        "language": { "$ref": "#/$defs/language" },
-        "languages": { "type": "array", "items": { "$ref": "#/$defs/language" }, "minItems": 1 }
-      }
+    "file": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/whole"
+        },
+        {
+          "$ref": "#/$defs/encoded"
+        }
+      ]
     },
-    "files": {
-      "type": "object",
-      "propertyNames": { "pattern": "^[A-Za-z0-9_][^\\\\]*$" },
-      "additionalProperties": {
-        "anyOf": [{ "$ref": "#/$defs/whole" }, { "$ref": "#/$defs/encoded" }, { "$ref": "#/$defs/parts" }]
-      }
+    "asset": {
+      "type": "string",
+      "pattern": "^assets/[0-9a-f]{64}\\.[a-z0-9]+$"
     },
-    "asset": { "type": "string", "pattern": "^assets/[0-9a-f]{64}\\.[a-z0-9]+$" },
     "encodedAsset": {
-      "description": "An asset stored gzip- or brotli-encoded: the SHA-256 of its decoded bytes, the logical file's extension, then .gz or .br.",
+      "description": "An asset stored gzip- or brotli-encoded: the SHA-256 of its decoded bytes, the file's extension, then .gz or .br.",
       "type": "string",
       "pattern": "^assets/[0-9a-f]{64}\\.[a-z0-9]+\\.(gz|br)$"
     },
-    "size": { "description": "The byte count of the file (decoded).", "type": "integer", "minimum": 0 },
-    "stored": { "description": "The byte count of an encoded asset as stored (less than size).", "type": "integer", "minimum": 0 },
-    "whole": {
-      "type": "object",
-      "required": ["asset", "size"],
-      "additionalProperties": false,
-      "properties": { "asset": { "$ref": "#/$defs/asset" }, "size": { "$ref": "#/$defs/size" } }
+    "size": {
+      "description": "The byte count of the file (decoded).",
+      "type": "integer",
+      "minimum": 0
     },
-    "encoded": {
+    "stored": {
+      "description": "The byte count of an encoded asset as stored (less than size).",
+      "type": "integer",
+      "minimum": 0
+    },
+    "whole": {
       "type": "object",
-      "required": ["asset", "size", "stored"],
+      "required": [
+        "asset",
+        "size"
+      ],
       "additionalProperties": false,
       "properties": {
-        "asset": { "$ref": "#/$defs/encodedAsset" },
-        "size": { "$ref": "#/$defs/size" },
-        "stored": { "$ref": "#/$defs/stored" }
+        "asset": {
+          "$ref": "#/$defs/asset"
+        },
+        "size": {
+          "$ref": "#/$defs/size"
+        }
       }
     },
-    "parts": {
+    "encoded": {
       "type": "object",
-      "required": ["parts", "size"],
+      "required": [
+        "asset",
+        "size",
+        "stored"
+      ],
       "additionalProperties": false,
       "properties": {
-        "parts": {
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "anyOf": [
-              {
-                "type": "array",
-                "prefixItems": [{ "type": "string" }, { "$ref": "#/$defs/asset" }, { "$ref": "#/$defs/size" }],
-                "minItems": 3,
-                "maxItems": 3
-              },
-              {
-                "type": "array",
-                "prefixItems": [{ "type": "string" }, { "$ref": "#/$defs/encodedAsset" }, { "$ref": "#/$defs/size" },
-                                { "$ref": "#/$defs/stored" }],
-                "minItems": 4,
-                "maxItems": 4
-              }
-            ]
-          }
+        "asset": {
+          "$ref": "#/$defs/encodedAsset"
+        },
+        "size": {
+          "$ref": "#/$defs/size"
         },
-        "size": { "$ref": "#/$defs/size" }
+        "stored": {
+          "$ref": "#/$defs/stored"
+        }
       }
     }
   }
diff --git a/schema/story-scene.schema.json b/schema/story-scene.schema.json
new file mode 100644
index 0000000..53ec99b
--- /dev/null
+++ b/schema/story-scene.schema.json
@@ -0,0 +1,146 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-scene.schema.json",
+  "title": "Story scene objects",
+  "required": [
+    "format",
+    "scene",
+    "renderSettings",
+    "prefabs",
+    "settings",
+    "graphics",
+    "bindings",
+    "shaders"
+  ],
+  "properties": {
+    "format": {
+      "const": 1
+    },
+    "scene": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "renderSettings": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "prefabs": {
+      "type": "object",
+      "required": [
+        "cameraManager",
+        "characterField",
+        "backgroundField",
+        "globalVolume"
+      ],
+      "properties": {
+        "cameraManager": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "characterField": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "backgroundField": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "globalVolume": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "settings": {
+      "type": "object",
+      "required": [
+        "playerSettings",
+        "masterIdSettings"
+      ],
+      "properties": {
+        "playerSettings": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "masterIdSettings": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "graphics": {
+      "type": "object",
+      "required": [
+        "graphics",
+        "player",
+        "quality"
+      ],
+      "properties": {
+        "graphics": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "player": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "quality": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "path",
+                "attribute"
+              ],
+              "properties": {
+                "path": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "attribute": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          },
+          "propertyNames": {
+            "type": "string",
+            "pattern": "^.+:-?[0-9]+$"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "shaders": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    }
+  }
+}
diff --git a/schema/story-simple-ui.schema.json b/schema/story-simple-ui.schema.json
new file mode 100644
index 0000000..7ac2542
--- /dev/null
+++ b/schema/story-simple-ui.schema.json
@@ -0,0 +1,239 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-simple-ui.schema.json",
+  "title": "Simple story UI objects",
+  "required": [
+    "uiManager",
+    "language",
+    "graphics",
+    "texts",
+    "textStyle",
+    "bindings",
+    "shaders",
+    "format",
+    "settings",
+    "talkWindow",
+    "systemMessage"
+  ],
+  "properties": {
+    "uiManager": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "language": {
+      "type": "object",
+      "title": "Story UI language settings",
+      "required": [
+        "code",
+        "mode",
+        "field",
+        "lineSpacing",
+        "fontNames",
+        "additionalFontNames",
+        "materialTypes",
+        "fontSwap"
+      ],
+      "properties": {
+        "code": {
+          "enum": [
+            "ja",
+            "en",
+            "zh-Hant",
+            "zh-Hans",
+            "ko"
+          ]
+        },
+        "mode": {
+          "enum": [
+            0,
+            1,
+            2,
+            3,
+            4
+          ]
+        },
+        "field": {
+          "enum": [
+            "japanese",
+            "english",
+            "traditionalChinese",
+            "simplifiedChinese",
+            "korean"
+          ]
+        },
+        "lineSpacing": {
+          "type": "number"
+        },
+        "fontNames": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "additionalFontNames": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "materialTypes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "fontSwap": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "graphics": {
+      "type": "object",
+      "required": [
+        "graphics"
+      ],
+      "properties": {
+        "graphics": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "player": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "quality": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "texts": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": [
+          "localized",
+          "style"
+        ],
+        "properties": {
+          "localized": {
+            "type": "object",
+            "required": [
+              "fontAsset",
+              "material",
+              "lineSpacing"
+            ],
+            "properties": {
+              "fontAsset": {
+                "type": "string",
+                "minLength": 1
+              },
+              "material": {
+                "type": "string",
+                "minLength": 1
+              },
+              "lineSpacing": {
+                "type": "number"
+              }
+            }
+          },
+          "style": {
+            "type": "object"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "textStyle": {
+      "type": "object"
+    },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "path",
+                "attribute"
+              ],
+              "properties": {
+                "path": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "attribute": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          },
+          "propertyNames": {
+            "type": "string",
+            "pattern": "^.+:-?[0-9]+$"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "shaders": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "format": {
+      "const": "nnnotes.story-simple-ui/1"
+    },
+    "settings": {
+      "type": "object",
+      "required": [
+        "dotween",
+        "tmpSettings",
+        "localizeManager"
+      ],
+      "properties": {
+        "dotween": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "tmpSettings": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "localizeManager": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "talkWindow": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "systemMessage": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    }
+  }
+}
diff --git a/schema/story-ui.schema.json b/schema/story-ui.schema.json
new file mode 100644
index 0000000..4414810
--- /dev/null
+++ b/schema/story-ui.schema.json
@@ -0,0 +1,281 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story-ui.schema.json",
+  "title": "Story UI objects",
+  "required": [
+    "format",
+    "widget",
+    "chatWidget",
+    "uiManager",
+    "letterbox",
+    "talkWindows",
+    "dialogs",
+    "clips",
+    "controllers",
+    "language",
+    "settings",
+    "graphics",
+    "texts",
+    "textStyle",
+    "bindings",
+    "shaders"
+  ],
+  "properties": {
+    "format": {
+      "const": 1
+    },
+    "widget": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "chatWidget": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "uiManager": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "letterbox": {
+      "type": "string",
+      "pattern": "^.+:-?[0-9]+$"
+    },
+    "talkWindows": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "dialogs": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "clips": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "controllers": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "language": {
+      "type": "object",
+      "title": "Story UI language settings",
+      "required": [
+        "code",
+        "mode",
+        "field",
+        "lineSpacing",
+        "fontNames",
+        "additionalFontNames",
+        "materialTypes",
+        "fontSwap"
+      ],
+      "properties": {
+        "code": {
+          "enum": [
+            "ja",
+            "en",
+            "zh-Hant",
+            "zh-Hans",
+            "ko"
+          ]
+        },
+        "mode": {
+          "enum": [
+            0,
+            1,
+            2,
+            3,
+            4
+          ]
+        },
+        "field": {
+          "enum": [
+            "japanese",
+            "english",
+            "traditionalChinese",
+            "simplifiedChinese",
+            "korean"
+          ]
+        },
+        "lineSpacing": {
+          "type": "number"
+        },
+        "fontNames": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "additionalFontNames": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "materialTypes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "fontSwap": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "settings": {
+      "type": "object",
+      "required": [
+        "dotween",
+        "tmpSettings",
+        "localizeManager",
+        "masterIdSettings"
+      ],
+      "properties": {
+        "dotween": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "tmpSettings": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "localizeManager": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "masterIdSettings": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "graphics": {
+      "type": "object",
+      "required": [
+        "graphics"
+      ],
+      "properties": {
+        "graphics": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "player": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        },
+        "quality": {
+          "type": "string",
+          "pattern": "^.+:-?[0-9]+$"
+        }
+      }
+    },
+    "texts": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": [
+          "localized",
+          "style"
+        ],
+        "properties": {
+          "localized": {
+            "type": "object",
+            "required": [
+              "fontAsset",
+              "material",
+              "lineSpacing"
+            ],
+            "properties": {
+              "fontAsset": {
+                "type": "string",
+                "minLength": 1
+              },
+              "material": {
+                "type": "string",
+                "minLength": 1
+              },
+              "lineSpacing": {
+                "type": "number"
+              }
+            }
+          },
+          "style": {
+            "type": "object"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "textStyle": {
+      "type": "object"
+    },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "path",
+                "attribute"
+              ],
+              "properties": {
+                "path": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                },
+                "attribute": {
+                  "type": [
+                    "string",
+                    "null"
+                  ]
+                }
+              }
+            }
+          },
+          "propertyNames": {
+            "type": "string",
+            "pattern": "^.+:-?[0-9]+$"
+          }
+        }
+      },
+      "propertyNames": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    },
+    "shaders": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^.+:-?[0-9]+$"
+      }
+    }
+  }
+}
diff --git a/schema/story.schema.json b/schema/story.schema.json
index 355bf22..9b2f572 100644
--- a/schema/story.schema.json
+++ b/schema/story.schema.json
@@ -1,50 +1,176 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story.schema.json",
-  "title": "Story index (story.json)",
-  "description": "The index of a story's logical files: episode, scene, UI, models, cue sheet directories and the media files of the kinds the episode uses. See docs/story-data-format.md.",
   "type": "object",
-  "required": ["advId", "episode", "scene", "ui", "models", "audio", "frames", "effects", "postEffects", "stills", "talkWindows", "chat", "videos"],
+  "$id": "https://raw.githubusercontent.com/empty-sekai/ournotes-player/main/schema/story.schema.json",
+  "title": "Story part index",
+  "required": [
+    "format",
+    "advId",
+    "episode",
+    "parts"
+  ],
   "properties": {
-    "advId": { "type": "integer", "minimum": 1 },
-    "episode": { "$ref": "#/$defs/path" },
-    "scene": { "$ref": "#/$defs/path" },
-    "ui": { "$ref": "#/$defs/path" },
-    "models": {
-      "description": "Model address (the address the Character rows name) -> the model's id: its model.json is under live2d/<id>/ of the story's file set, its objects in the store's object table.",
-      "type": "object",
-      "propertyNames": { "pattern": "^Character/Live2D/[^/]+/[^/]+/model/[^/]+$" },
-      "additionalProperties": { "type": "string", "pattern": "^[a-z0-9_]+$" }
+    "format": {
+      "const": 1
+    },
+    "advId": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "episode": {
+      "const": "episode.json"
     },
-    "modelsDir": {
-      "description": "A story directory only (not a site): the directory holding the models (<modelsDir>/<id>/model.json, ...), relative to the story directory, \"/\"-separated.",
-      "type": "string",
-      "minLength": 1
+    "chats": {
+      "type": "object"
     },
-    "audio": {
+    "effects": {
       "type": "object",
-      "propertyNames": { "minLength": 1 },
-      "additionalProperties": { "$ref": "#/$defs/path" }
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "host": {
+      "type": [
+        "object",
+        "null"
+      ]
     },
-    "frames": { "$ref": "#/$defs/optionalPath" },
-    "effects": { "$ref": "#/$defs/optionalPath" },
-    "postEffects": { "$ref": "#/$defs/optionalPath" },
-    "stills": { "$ref": "#/$defs/optionalPath" },
-    "talkWindows": { "$ref": "#/$defs/optionalPath" },
-    "chat": { "$ref": "#/$defs/optionalPath" },
-    "videos": { "$ref": "#/$defs/optionalPath" },
-    "crilips": {
-      "description": "The CRI Lips analysis data (docs/crilips.md): the descriptor (crilips.json) and the float32 weights (crilips.bin). null (or absent in older sites) when no voice of the story reaches the CRI Lips analysis.",
-      "type": ["object", "null"],
-      "required": ["descriptor", "data"],
+    "parts": {
+      "type": "object",
+      "required": [
+        "scene",
+        "assets",
+        "models",
+        "sounds",
+        "ui",
+        "fonts"
+      ],
       "properties": {
-        "descriptor": { "type": "string", "pattern": "^[A-Za-z0-9_][^\\\\]*\\.json$" },
-        "data": { "type": "string", "pattern": "^[A-Za-z0-9_][^\\\\]*\\.bin$" }
-      }
+        "scene": {
+          "type": "string",
+          "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+        },
+        "chat": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "crilips": {
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "assets": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "models": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "sounds": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "videos": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "host": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "spots": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "rooms": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          }
+        },
+        "ui": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          },
+          "propertyNames": {
+            "enum": [
+              "ja",
+              "en",
+              "zh-Hant",
+              "zh-Hans",
+              "ko"
+            ]
+          }
+        },
+        "fonts": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          },
+          "propertyNames": {
+            "enum": [
+              "ja",
+              "en",
+              "zh-Hant",
+              "zh-Hans",
+              "ko"
+            ]
+          }
+        },
+        "simpleui": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^/\\\\?#]+(?:/[^/\\\\?#]+)+\\.json$"
+          },
+          "propertyNames": {
+            "enum": [
+              "ja",
+              "en",
+              "zh-Hant",
+              "zh-Hans",
+              "ko"
+            ]
+          }
+        }
+      },
+      "additionalProperties": false
     }
-  },
-  "$defs": {
-    "path": { "type": "string", "pattern": "^[A-Za-z0-9_][^\\\\]*$" },
-    "optionalPath": { "type": ["string", "null"], "pattern": "^[A-Za-z0-9_][^\\\\]*\\.json$" }
   }
 }
diff --git a/scripts/check-contracts.mjs b/scripts/check-contracts.mjs
index d2a040d..eea16dd 100644
--- a/scripts/check-contracts.mjs
+++ b/scripts/check-contracts.mjs
@@ -179,7 +179,7 @@ const checkSchemas = () => {
 
 // ------------------------------------------------------------------------------------------------ formats
 
-const FORMAT_ID = /\bournotes\.[a-z][a-z0-9-]*\/\d+\b/g;
+const FORMAT_ID = /\b(?:ournotes|nnnotes)\.[a-z][a-z0-9.-]*\/\d+\b/g;
 
 const checkFormats = () => {
   const ids = (files) => {
diff --git a/scripts/lib/headless.mjs b/scripts/lib/headless.mjs
index ecd4813..2377d86 100644
--- a/scripts/lib/headless.mjs
+++ b/scripts/lib/headless.mjs
@@ -246,19 +246,19 @@ export class DirStore extends AssetStore {
   }
 }
 
-// a story directory (story.json, episode.json, ...) as a store: with story.json `modelsDir` (the models directory,
-// relative to the story directory), its models' files under live2d/<model id>/
-export const storyDirStore = (dir, info = null) => {
-  const index = JSON.parse(fs.readFileSync(path.join(dir, "story.json"), "utf8"));
-  const mounts = typeof index.modelsDir === "string" ? { live2d: path.resolve(dir, ...index.modelsDir.split("/")) } : {};
-  return new DirStore(dir, info, { mounts });
-};
-
-// a story: a manifest file (site/stories/<advId>.json, the site's models and assets beside it) loaded in one language
-// (default: the manifest's), or a story directory (storyDirStore)
+// A story product manifest, or a product layout containing exactly one story manifest.
 export const openStory = async (where, { lang = null } = {}) => {
-  const p = path.resolve(where);
-  if (fs.statSync(p).isDirectory()) return headlessImages(storyDirStore(p));
+  let p = path.resolve(where);
+  if (fs.statSync(p).isDirectory()) {
+    const dir = path.join(p, "stories"), files = [];
+    const scan = (d) => { for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const f = path.join(d, e.name);
+      if (e.isDirectory()) scan(f); else if (e.isFile() && e.name.endsWith(".json")) files.push(f);
+    } };
+    if (fs.existsSync(dir)) scan(dir);
+    if (files.length !== 1) throw new Error(`${p}: choose a story product manifest (found ${files.length} in stories/)`);
+    p = files[0];
+  }
   const { loadStoryStore } = await import("../../src/story/assets.js");
   return headlessImages(await loadStoryStore(pathToFileURL(p).href, { fetch: fileFetch, lang, decode: nodeDecode }));
 };
diff --git a/scripts/lib/story-author/script.js b/scripts/lib/story-author/script.js
index 6909e63..cdf3ddc 100644
--- a/scripts/lib/story-author/script.js
+++ b/scripts/lib/story-author/script.js
@@ -261,7 +261,7 @@ export const applyFixes = (doc, problems) => {
 // The music of a base story: the sound rows of its episode whose cue sheet is a BGM sheet the story has the sound
 // files of (story.json audio) -> [{cue, label, sound, sheet}], by cue name.
 export const musicChoices = (episode, story) => {
-  const audio = (story && story.audio) || {}, out = new Map();
+  const audio = story?.parts?.sounds || {}, out = new Map();
   for (const [id, row] of Object.entries((episode && episode.sounds) || {})) {
     const sheet = episode.cuesheets && episode.cuesheets[row._soundCueSheetID];
     const name = sheet && sheet._cueSheetName;
@@ -274,9 +274,9 @@ export const musicChoices = (episode, story) => {
 // The stages of a base story: [{id, key, caption}] in the order its episode sets them (the others last, by key). The
 // id is the key's last segment, or the whole key where two keys end alike; the caption is the first location caption
 // (in `language`) the episode shows while that stage is set, or "".
-export const stageChoices = (scene, episode, language) => {
+export const stageChoices = (assets, episode, language) => {
   const field = STORY_LANGUAGES[language];
-  const keys = Object.keys((scene && scene.stages) || {}), captions = new Map(), order = [];
+  const keys = Object.keys(assets || {}).filter((k) => k.startsWith("Adv/Stage/")).map((k) => k.slice(10)), captions = new Map(), order = [];
   let cur = null;
   for (const c of (episode && episode.commands) || []) {
     if (c.IgnoreData) continue;
@@ -294,15 +294,10 @@ export const stageChoices = (scene, episode, language) => {
   return order.map((key) => ({ id: count.get(last(key)) > 1 ? key : last(key), key, caption: captions.get(key) || "" }));
 };
 
-// The texture path of a stage's background sprite (a prefab of scene.json stages), or null.
-export const stageBackground = (prefab) => {
-  for (const n of (prefab && prefab.nodes) || []) for (const c of n.components || []) {
-    if (c && c.class === "AdvStage") {
-      const t = c._backgroundSprite && c._backgroundSprite.texture;
-      return t && typeof t.texture === "string" ? t.texture : null;
-    }
-  }
-  return null;
+// The Texture2D object id of the stage's background Sprite, or null.
+export const stageBackground = (prefab, objects) => {
+  const stage = prefab.find("AdvStage").c.fields;
+  return objects.sprite(stage._backgroundSprite)?.texture.id || null;
 };
 
 // ------------------------------------------------------------------------------------------------ models
@@ -340,7 +335,7 @@ export const resolveMotion = (motion, slot, motions) => {
 
 // ------------------------------------------------------------------------------------------------ fonts
 
-// ui/fonts.json of the base story with every font asset drawn by the browser in `family` (the story player's browser
+// The base story's font product with every font asset drawn by the browser in `family` (the story player's browser
 // fonts): the asset keeps its point size, padding, render mode, style settings, line metrics and fallbacks; its
 // characters and glyphs are made as texts use them, so every character of the family shows (no missing glyph). The
 // glyph cell margin keeps the room the asset's text materials need for their underlay offset.
@@ -359,6 +354,10 @@ export const withBrowserFonts = (fonts, family) => {
     f.glyphs = {};
     delete f.missingGlyph;
   }
+  if (out.coverage) {
+    out.coverage.characters = 0; out.coverage.missing = [];
+    delete out.coverage.missingGlyph;
+  }
   return out;
 };
 
@@ -610,13 +609,14 @@ export const compileScript = (script, site, language) => {
 
   // the models: one Character row per cast member that comes on stage (the player loads them before playing)
   const onStageEver = new Set(script.beats.flatMap((b) => (b.positions || []).map((p) => p.cast)));
-  const story = { ...base.story, advId: 0, episode: "episode.json", models: {}, audio: {},
-                  frames: null, effects: null, postEffects: null, stills: null, talkWindows: null, chat: null,
-                  videos: null, crilips: null };
+  const story = { format: 1, advId: 0, episode: "episode.json", chats: {}, effects: {},
+    parts: { scene: base.story.parts.scene, ui: { ...base.story.parts.ui }, fonts: { ...base.story.parts.fonts },
+      assets: Object.fromEntries(Object.entries(base.story.parts.assets).filter(([key]) => /^Adv\/(Stage|Transition)\//.test(key))),
+      models: {}, sounds: {}, videos: {} } };
   for (const c of script.cast) {
     if (!onStageEver.has(c.id)) continue;
     const key = models[c.model];
-    story.models[key] = c.model;
+    story.parts.models[key] = c.model;
     row("Character", { TargetName: c.id, TargetAssetName: key.replace(/^Character\/Live2D\//, "") });
   }
 
@@ -701,14 +701,14 @@ export const compileScript = (script, site, language) => {
     const s = base.episode.sounds[r.BgmID], sheet = base.episode.cuesheets[s._soundCueSheetID];
     sounds[r.BgmID] = s;
     cuesheets[s._soundCueSheetID] = sheet;
-    story.audio[sheet._cueSheetName] = base.story.audio[sheet._cueSheetName];
+    story.parts.sounds[sheet._cueSheetName] = base.story.parts.sounds[sheet._cueSheetName];
   }
   const title = script.title.trim();
   const episode = {
     advId: 0, asset: "", commandCount: rows.length, commands: rows,
     text: { ...(title ? { [TITLE_ID]: { [field]: plainText(title) } } : {}), ...text },
     sounds, cuesheets, videos: {}, resources: [],
-    master: { _id: 0, _sheetName: "", _advEpisodeAsset: "", _titleTextId: title ? TITLE_ID : 0, _rubyTitleTextId: 0,
+    master: { _id: 0, _sheetName: "", _advEpisodeAsset: "", _titleTextId: title ? TITLE_ID : "", _rubyTitleTextId: "",
               _playbackMode: 0 },
     title: title ? { [field]: plainText(title) } : null,
   };
diff --git a/scripts/lib/story-author/site.js b/scripts/lib/story-author/site.js
index 2542b25..f664b58 100644
--- a/scripts/lib/story-author/site.js
+++ b/scripts/lib/story-author/site.js
@@ -1,25 +1,18 @@
-// A story site on disk as the story author reads it: the story index, the model index, base stories, models, and the
-// story manifest of a compiled script (ournotes.story-manifest/2 with the base story's files, the script's own
-// story.json, episode.json and ui/fonts.json, and the model manifests of its cast).
+// Story products on disk: the indexes, reusable parts, and the products of a compiled script.
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { AssetStore } from "../../../src/data/assets.js";
-import { STORY_MANIFEST_FORMAT, checkModelManifest } from "../../../src/story/assets.js";
-import { StoryPlayerCore } from "../../../src/story/player-core.js";
+import { STORY_MANIFEST_FORMAT, checkModelManifest, loadStoryStore } from "../../../src/story/assets.js";
+import { StoryData } from "../../../src/story/data.js";
+import { ObjectResources } from "../../../src/engine/objects.js";
 import "../../../src/story/features/index.js";
 import { fileFetch, nodeDecode } from "../headless.mjs";
 import { modelActions, musicChoices, stageBackground, stageChoices, withBrowserFonts } from "./script.js";
 
 export class SiteError extends Error {}
 
-// the common files of a base story a script does not play: the media of the base episode's own rows, its videos and
-// CRI Lips data, and the host screen of an Overlay episode
-const MEDIA = new Set(["frames.json", "effects.json", "posteffects.json", "stills.json", "talkwindows.json", "chat.json"]);
-const skipped = (p) => MEDIA.has(p) || /^(videos|crilips|host)\//.test(p) || p.startsWith("ui/simple/");
-const textureRefs = (text) => [...text.matchAll(/"(textures\/[^"]+)"/g)].map((m) => m[1]);
-
 const sha256 = (b) => crypto.createHash("sha256").update(b).digest("hex");
 const sortKeys = (o) => Object.fromEntries(Object.keys(o).sort().map((k) => [k, o[k]]));
 
@@ -73,30 +66,29 @@ export class Site {
     return this._bases.get(key);
   }
 
+  languages(manifestPath) {
+    const manifest = this.json(manifestPath);
+    if (manifest.schema !== STORY_MANIFEST_FORMAT || manifest.product !== "story")
+      throw new SiteError(`${manifestPath}: a base story needs a story product`);
+    return Object.keys(this.json(manifest.files["story.json"].asset).parts.ui);
+  }
+
   async _loadBase(manifestPath, lang) {
     const manifest = this.json(manifestPath);
-    if (manifest.format !== STORY_MANIFEST_FORMAT)
-      throw new SiteError(`${manifestPath}: a base story needs a story manifest of format ${STORY_MANIFEST_FORMAT}` +
-                          ` (this one is ${manifest.format})`);
-    if (manifest.story && manifest.story.playbackMode === 1)
-      throw new SiteError(`${manifestPath}: an Overlay episode (home talk, live result) cannot be a base story`);
-    const languages = Object.keys(manifest.languages || {});
-    const language = lang || manifest.language;
-    if (!manifest.languages[language]) throw new SiteError(`${manifestPath}: no language ${language} (${languages.join(", ")})`);
-    const files = {};
-    for (const p of ["story.json", "episode.json", "scene.json"]) {
-      if (!manifest.files[p]) throw new SiteError(`${manifestPath}: no ${p}`);
-      files[p] = manifest.files[p];
-    }
-    const lf = manifest.languages[language].files;
-    if (!lf["ui/fonts.json"]) throw new SiteError(`${manifestPath}: no ui/fonts.json in ${language}`);
-    files["ui/fonts.json"] = lf["ui/fonts.json"];
-    const store = await this.store(files);
-    const story = store.json("story.json"), episode = store.json("episode.json"), scene = store.json("scene.json");
-    const stages = stageChoices(scene, episode, language)
-      .map((s) => ({ ...s, background: stageBackground(scene.stages[s.key]) }));
-    return { path: manifestPath, manifest, language, languages, story, episode, scene, fonts: store.json("ui/fonts.json"),
-             stages, music: musicChoices(episode, story), cast: Object.values(story.models || {}) };
+    if (manifest.schema !== STORY_MANIFEST_FORMAT || manifest.product !== "story")
+      throw new SiteError(`${manifestPath}: a base story needs a story product`);
+    const language = lang || manifest.language || "ja";
+    const store = await loadStoryStore(pathToFileURL(this.file(manifestPath)).href,
+      { lang: language, fetch: fileFetch, decode: nodeDecode });
+    const data = new StoryData(store), { story, episode, scene, fonts } = data;
+    if (episode.master?._playbackMode === 1) throw new SiteError(`${manifestPath}: an Overlay episode cannot be a base story`);
+    const objects = new ObjectResources(store, data.resourceOptions());
+    const stages = stageChoices(story.parts.assets, episode, language).map((s) => {
+      const asset = data.asset(`Adv/Stage/${s.key}`);
+      return { ...s, background: stageBackground(objects.prefab(asset.objects[0]), objects) };
+    });
+    return { path: manifestPath, manifest, language, languages: Object.keys(story.parts.ui), story, episode, scene, fonts,
+      stages, music: musicChoices(episode, story), cast: Object.keys(story.parts.models).map((key) => key.split("/").at(-1)), data, store };
   }
 
   // The model `id` of models.json: {entry, manifest, actions: modelActions}
@@ -117,52 +109,31 @@ export class Site {
     return { entry, manifest, actions: modelActions(store, store.json("model.json")) };
   }
 
-  // the bytes of logical files of a base story (path -> Buffer), from its common files
-  async baseFiles(base, paths) {
-    const files = {};
-    for (const p of paths) if (base.manifest.files[p]) files[p] = base.manifest.files[p];
-    const store = await this.store(files);
-    return new Map(Object.keys(files).map((p) => [p, Buffer.from(store.bytes(p))]));
+  // The image bytes of the background Texture2D objects selected from the base story.
+  async baseFiles(base, ids) {
+    return new Map(ids.map((id) => [id, Buffer.from(base.store.objectBytes(id, "image"))]));
   }
 
   // The story manifest of a compiled script (compileScript) on the base story `base`, played in `language` with its
   // texts drawn in the CSS font family `family`, placed where `root` is the site root seen from the manifest.
   // -> {manifest, assets: Map(asset path -> Buffer)}: the assets it adds to the site (assets/<sha256>.json)
-  async compose(base, compiled, { language, family, title, root = "../" }) {
+  async compose(base, compiled, { language, family, root = "../" }) {
     const assets = new Map();
     const entry = (doc) => {
       const b = Buffer.from(JSON.stringify(doc), "utf8"), asset = `assets/${sha256(b)}.json`;
       assets.set(asset, b);
       return { asset, size: b.length };
     };
-    const sheets = Object.values(compiled.story.audio);
-    const keep = (p) => !skipped(p) && (!p.startsWith("audio/") || sheets.some((d) => p.startsWith(`${d}/`)));
-    // textures: the ones the kept JSON files name
-    const lang = base.manifest.languages[language].files;
-    const kept = { ...Object.fromEntries(Object.entries(base.manifest.files).filter(([p]) => keep(p))), ...lang };
-    const jsonStore = await this.store(Object.fromEntries(Object.entries(kept)
-      .filter(([p]) => p.endsWith(".json") && !["story.json", "episode.json", "ui/fonts.json"].includes(p))));
-    const textures = new Set();
-    for (const p of jsonStore.list()) for (const t of textureRefs(jsonStore.text(p))) textures.add(t);
-    const files = {};
-    for (const [p, f] of Object.entries(base.manifest.files))
-      if (keep(p) && (!p.startsWith("textures/") || textures.has(p))) files[p] = f;
-    files["story.json"] = entry(compiled.story);
-    files["episode.json"] = entry(compiled.episode);
-    const langFiles = { ...lang, "ui/fonts.json": entry(withBrowserFonts(base.fonts, family)) };
-
-    const models = {};
-    for (const id of Object.values(compiled.story.models)) models[id] = (await this.model(id)).entry.manifest;
-    const commands = StoryPlayerCore.requiredCommands(compiled.episode, base.scene.settings.playerSettings);
-    const audio = sheets.length > 0;
-    const facts = { advId: 0, asset: "", playbackMode: 0, titles: title ? { [language]: title } : {}, groups: [], commands,
-                    commandCount: compiled.episode.commandCount, language, languages: [language] };
-    const manifest = {
-      format: STORY_MANIFEST_FORMAT, advId: 0, root, story: facts, language, audio,
-      audioFormat: audio ? base.manifest.audioFormat : null, fonts: base.manifest.fonts,
-      requires: { commands, cubismCore: true, motionSync: false },
-      files: sortKeys(files), models: sortKeys(models), languages: { [language]: { files: sortKeys(langFiles) } },
-    };
+    const story = structuredClone(compiled.story), parts = story.parts;
+    for (const [key, id] of Object.entries(parts.models)) parts.models[key] = (await this.model(id)).entry.manifest;
+    const fonts = withBrowserFonts(base.fonts, family), source = this.json(base.story.parts.fonts[language]);
+    const fontEntry = entry(fonts), fontPath = `storyfonts/0_${language}_${sha256(Buffer.from(JSON.stringify(fonts)))}.json`;
+    assets.set(fontPath, Buffer.from(JSON.stringify({ schema: STORY_MANIFEST_FORMAT, product: "story.fonts", subject: `0/${language}`,
+      files: { ...source.files, "fonts.json": fontEntry }, objects: source.objects })));
+    parts.fonts = { [language]: fontPath };
+    parts.ui = { [language]: base.story.parts.ui[language] };
+    const manifest = { schema: STORY_MANIFEST_FORMAT, product: "story", subject: "0", root, language,
+      files: sortKeys({ "story.json": entry(story), "episode.json": entry(compiled.episode) }), objects: {} };
     return { manifest, assets };
   }
 }
diff --git a/scripts/story-author.mjs b/scripts/story-author.mjs
index 7b23d20..1304cc5 100644
--- a/scripts/story-author.mjs
+++ b/scripts/story-author.mjs
@@ -141,7 +141,7 @@ const loadScript = async (site, file) => {
   let base = null;
   if (script.base) {
     try {
-      const languages = Object.keys(site.json(script.base).languages || {});
+      const languages = site.languages(script.base);
       base = await site.base(script.base, languages.includes(script.language) ? script.language : null);
     } catch (e) {
       if (!(e instanceof SiteError)) throw e;
diff --git a/scripts/validate-data.mjs b/scripts/validate-data.mjs
index dfd10ba..ff5a393 100644
--- a/scripts/validate-data.mjs
+++ b/scripts/validate-data.mjs
@@ -25,18 +25,9 @@
 // Without charts.json the manifests are charts/*.json and charts/<region>/*.json. A models.json entry's id, key and
 // group must be those of its manifest's subject, its canvas and textures those of model.json, its bytes and files those
 // of the manifest's files and its objects' files.
-// Stories (stories.json, stories/<advId>.json, stories/<region>/<advId>.json; docs/story-data-format.md): the manifest
-// (schema, root, language groups, agreement with stories.json), every asset of the common files and of each language
-// group, story.json, episode.json, the required commands against the episode's rows and the player settings, the cue
-// sheets (cues.json, waveform files and their FLAC / MP4 headers), the Live2D models (the model manifests the manifest
-// lists, each valid as a model, one per model story.json names; no story file under live2d/), the Animator controller
-// and clip references of the media files, both
-// shader directories, texture
-// descriptors, and per language ui/ui.json, ui/languages.json and ui/fonts.json (text bindings, the dialog, chat
-// window and frame bindings, font assets with their fallbacks and missing glyph, fallback materials, sprite assets,
-// glyph pages, text material shaders). An Overlay story built with open fonts: its host (host/host.json and, per
-// language, ui/simple/ui.json with ui/simple/fonts.json). A story id is the manifest path below stories/ without .json
-// (`10462`, `tw/10462`).
+// Stories (stories/<id>.json): story products and their part graph, every selected language's UI and font bindings,
+// scene and media object references, cue waveforms, CRI Lips bounds, and model products. Products share objects;
+// their files and checks are cached by content while each language is validated against its own bindings.
 // Prints the failures and a summary; exits 1 when a live, a chart, a model or a story fails. No dependencies.
 
 import crypto from "node:crypto";
@@ -49,8 +40,16 @@ import { LiveData } from "../src/live/data.js";
 import { legacyLive } from "../src/live/legacy.js";
 import { LiveOptionContext } from "../src/live/settings.js";
 import { LIVE_PARTS, LIVE_PRODUCT, liveManifest, productDir } from "../src/live/store.js";
-import { animRecordProblems } from "../src/story/features/clips.js";
-import { ADV_COMMAND } from "../src/story/interfaces.js";
+import { storyPartRequests } from "../src/story/store.js";
+import { StoryData } from "../src/story/data.js";
+import { StoryPlayerCore } from "../src/story/player-core.js";
+import { simpleUnsupportedCommands } from "../src/story/simple/validator.js";
+import { ObjectResources } from "../src/engine/objects.js";
+import { HomeScene } from "../src/story/simple/home/objects.js";
+import { spotLighting } from "../src/story/simple/home/host.js";
+import { hostUIRoots } from "../src/story/simple/objects.js";
+import { SimpleUIDoc } from "../src/story/simple/ui.js";
+import { mergeProductManifests } from "../src/data/products.js";
 import { compile } from "./lib/json-schema.mjs";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -61,9 +60,19 @@ const S = {
   noteeffect: schema("live-noteeffect"), sounds: schema("live-sounds"), music: schema("live-music"), models: schema("models"), product: schema("product"), modelJson: schema("model-json"),
   stories: schema("stories"), storyManifest: schema("story-manifest"), story: schema("story"), episode: schema("episode"),
   storyFonts: schema("story-fonts"), storyLanguage: schema("story-language"),
+  storyScene: schema("story-scene"), storyUI: schema("story-ui"), storySimpleUI: schema("story-simple-ui"),
+  storyHost: schema("story-host"), storyAsset: schema("story-asset"),
 };
 
-const STORY_HOST_FORMAT = "ournotes.story-host/1";
+const SCHEMA_STORY_FONTS = S.storyFonts;
+const STORY_DOCS = { "story.scene": ["scene.json", "storyScene"], "story.ui": ["ui.json", "storyUI"],
+  "story.simpleui": ["ui.json", "storySimpleUI"], "story.host": ["host.json", "storyHost"], "story.asset": ["asset.json", "storyAsset"] };
+const GRAPHICS_CLASSES = { graphics: "GraphicsSettings", player: "PlayerSettings", quality: "QualitySettings" };
+const STORY_REFS = { "story.scene": { scene: "GameObject", renderSettings: "RenderSettings", prefabs: "GameObject" },
+  "story.ui": { widget: "GameObject", chatWidget: "GameObject", uiManager: "GameObject", talkWindows: "GameObject", dialogs: "GameObject",
+    letterbox: "Sprite", clips: "AnimationClip", controllers: "AnimatorController" },
+  "story.simpleui": { talkWindow: "GameObject", systemMessage: "GameObject", uiManager: "GameObject" },
+  "story.host": { cameraTarget: "GameObject", dotween: "MonoBehaviour", prefabs: "GameObject" } };
 const extOf = (p) => (p.match(/\.([A-Za-z0-9]+)$/) || [])[1]?.toLowerCase() ?? "";
 // encoded assets (assets/<sha256>.<ext>.gz / .br): the encoding, the logical file's extension, the extensions that may
 // be encoded (every other file is stored as it is)
@@ -551,12 +560,13 @@ class LiveChecks {
 
   // every object of the store: its JSON files parse; a Texture2D's image is a PNG of its size; a Shader's parsed form
   // and variant index, and the GLES3 programs of the shaders its Materials use; a Mesh's arrays
-  objects() {
+  objects({ selectedPrograms = false, materialKeywords = new Map() } = {}) {
     const drawn = new Set();
+    const materials = new Map();
     for (const id of objectIds(this.S)) {
       if (this.S.object(id).class !== "Material") continue;
-      const r = this.ofObject("materialshader", id, "json", (b) => { try { return { shader: refOf(JSON.parse(b).shader) }; } catch { return {}; } });
-      if (r.shader) drawn.add(r.shader);
+      const r = this.ofObject("materialshader", id, "json", (b) => { try { const m = JSON.parse(b); return { shader: refOf(m.shader), keywords: m.keywords || [] }; } catch { return {}; } });
+      if (r.shader) { drawn.add(r.shader); if (!materials.has(r.shader)) materials.set(r.shader, []); materials.get(r.shader).push(...(materialKeywords.get(id) || [r.keywords])); }
     }
     for (const id of objectIds(this.S)) {
       const o = this.S.object(id), roles = this.S.roles(id), where = `${o.class} ${id}${o.name ? ` (${o.name})` : ""}`;
@@ -583,14 +593,24 @@ class LiveChecks {
         report(json("json", parsedShaderErrors));
         const ix = report(json("index", (v) => (isObj(v) && typeof v.name === "string" && Array.isArray(v.variants) ? [] : ["index: not a variant index"])));
         if (!ix || !drawn.has(id)) continue;
+        if (selectedPrograms) for (const keywords of materials.get(id) || []) {
+          const selected = variantFor([{ name: ix.v.name, variants: ix.v.variants.filter((v) => v.platform === SHADER_PLATFORM && v.type === SHADER_PROGRAM_TYPE && v.stage === "vertex") }], ix.v.name, keywords);
+          if (selected.error) this.err(where, selected.error);
+          else if (!roles.includes(selected.variant.role)) this.err(where, `material [${keywords.join(" ")}]: no ${selected.variant.role} file`);
+        }
         for (const v of ix.v.variants) {
           if (v.platform !== SHADER_PLATFORM || v.type !== SHADER_PROGRAM_TYPE) continue;
+          if (selectedPrograms && !roles.includes(v.role)) continue;
           if (!roles.includes(v.role)) { this.err(where, `no ${v.role} file`); continue; }
           for (const e of this.ofObject("glsl", id, v.role, (b) => glslStages(b.toString("utf8")))) this.err(`${where} ${v.role}`, e);
         }
       } else if (o.class === "Mesh") {
         report(json("json"));
-        if (!roles.includes("arrays")) { this.err(where, "no arrays file"); continue; }
+        if (!roles.includes("arrays")) {
+          const mesh = this.S.objectJson(id);
+          if (mesh.m_VertexData?.m_VertexCount !== 0 || mesh.m_SubMeshes?.some((s) => s.indexCount > 0)) this.err(where, "no arrays file");
+          continue;
+        }
         report(json("arrays", (v) => (isObj(v) && Array.isArray(v.positions) && Array.isArray(v.submeshes)
           && v.submeshes.every((s) => isObj(s) && typeof s.topology === "string" && (s.indices === null || Array.isArray(s.indices)))
           ? [] : ["arrays: needs positions and submeshes [{topology, indices}]"])));
@@ -644,26 +664,6 @@ function nodeList(pf, where, errs) {
   }
 }
 
-const isDescriptor = (o) => isObj(o) && typeof o.texture === "string" && /\.png$/i.test(o.texture) &&
-  Number.isInteger(o.width) && Number.isInteger(o.height);
-const desc = (o) => ({ texture: o.texture, width: o.width, height: o.height, mipCount: o.mipCount ?? 1, name: o.name });
-const dirOf = (p) => (p.includes("/") ? p.slice(0, p.lastIndexOf("/")) : "");
-const inDir = (dir, p) => (dir ? `${dir}/${p}` : p);
-
-// every object inside v (skipping the top-level keys in `skip`)
-function walk(v, fn, skip = []) {
-  const stack = [v];
-  let top = true;
-  while (stack.length) {
-    const o = stack.pop();
-    if (Array.isArray(o)) { for (const x of o) if (x && typeof x === "object") stack.push(x); continue; }
-    if (!o || typeof o !== "object") continue;
-    fn(o);
-    for (const [k, x] of Object.entries(o)) if (x && typeof x === "object" && !(top && skip.includes(k))) stack.push(x);
-    top = false;
-  }
-}
-
 // ------------------------------------------------------------------------------------------------ one Live2D model
 const LIT_SHADER = "Live2D Cubism/Lit-URP-ADV-optimize", MASK_SHADER = "Live2D Cubism/Mask";
 const ROOT_COMPONENTS = ["Live2DCharacter", "CubismFadeController", "CubismExpressionController", "CubismRenderController",
@@ -780,7 +780,7 @@ class Product extends Chart {
   doc(kind, id, role, where, check = () => []) {
     const p = this.role(id, role, where);
     if (!p) return null;
-    const r = this.json(kind, p, (v) => { const errs = check(v); return { errs, v: errs.length ? null : v }; });
+    const r = this.json(`product:${kind}`, p, (v) => { const errs = check(v); return { errs, v: errs.length ? null : v }; });
     return r ? r.v : null;
   }
 }
@@ -1015,7 +1015,6 @@ class Live extends Product {
 // LanguageMode and text field per language (ui/languages.json)
 const STORY_LANGUAGES = { ja: [0, "japanese"], en: [1, "english"], "zh-Hant": [2, "traditionalChinese"],
   "zh-Hans": [3, "simplifiedChinese"], ko: [4, "korean"] };
-const STORY_MEDIA = ["frames", "effects", "postEffects", "stills", "talkWindows", "chat", "videos"];
 const TMP_TEXT_CLASSES = new Set(["TextMeshProUGUI", "RubyTextMeshProUGUI", "RubyEmojiTextMeshProUGUI"]);
 const TMP_SPRITE_SHADER = "TextMeshPro/Sprite";
 // TMP_Text.SetArraySizes: TMP_Settings.missingGlyphCharacter 0 is U+25A1; without it U+0020, then U+0003 (a control
@@ -1044,24 +1043,11 @@ const scaleRatios = (fl, keywords) => {
   return { a, c };
 };
 const mainTexName = (m) => (isObj(m.textures) && isObj(m.textures._MainTex) && isObj(m.textures._MainTex.texture) ? m.textures._MainTex.texture.name : null);
-// the text nodes of frames.json: frame name -> {node path: node} of the nodes with a TextMeshPro component (frames
-// without one left out)
-const frameTextNodes = (doc) => {
-  const out = {};
-  for (const [name, rec] of Object.entries(isObj(doc) && isObj(doc.frames) ? doc.frames : {})) {
-    const nodes = isObj(rec) && Array.isArray(rec.nodes) ? rec.nodes : [];
-    const texts = nodes.filter((n) => isObj(n) && Array.isArray(n.components) && n.components.some((c) => isObj(c) && TMP_TEXT_CLASSES.has(c.class)));
-    if (texts.length) out[name] = Object.fromEntries(texts.map((n) => [n.path, n]));
-  }
-  return out;
-};
 const WAVE_EXT = { aac: "m4a", flac: "flac" };
 // JSON text with object keys sorted (comparison independent of key order)
 const canon = (v) => JSON.stringify(v, (k, x) => (isObj(x) ? Object.fromEntries(Object.keys(x).sort().map((y) => [y, x[y]])) : x));
 const sameJson = (a, b) => canon(a) === canon(b);
 const sizeOf = (files) => Object.values(files).reduce((n, f) => n + (isObj(f) && Number.isInteger(f.size) ? f.size : 0), 0);
-const truthy = (v) => (Array.isArray(v) ? v.length > 0 : isObj(v) ? Object.keys(v).length > 0 : Boolean(v));
-const commandName = (v) => ADV_COMMAND[v] || `Cmd${v}`;
 
 // the variant of shader `name` in a parsed shader index that draws a material with `keywords`: the variant of sub
 // shader 0, pass 0 whose keywords equal the material's keywords that the shader's variants use
@@ -1085,413 +1071,281 @@ function storyVariant(list, keywords) {
   return { error: `${LIT_SHADER}: no variant for [${want}] (the story renderer's keywords at quality 4)` };
 }
 
-class Story extends Chart {
-  constructor(site, id, man, where = null) {
-    super(site, id, man, where);
-    this.common = this.files;
-    this.groups = isObj(man.languages) ? man.languages : {};
-    this.lang = null;                 // the language group being checked (error prefix)
-    this.fallbackSeen = new Set();    // the fallback materials checked (document, text material, fallback asset)
-  }
+// A story and the products its part index selects. Each language is checked through the same StoryData view as playback.
+class Story extends Product {
+  constructor(...args) { super(...args); this.lang = null; this.fallbackSeen = new Set(); this.partCache = new Map(); }
 
-  err(where, msg) { this.errs.push(`${this.lang ? `[${this.lang}] ` : ""}${where}: ${msg}`); }
+  err(where, message) { this.errs.push(`${this.lang ? `[${this.lang}] ` : ""}${where}: ${message}`); }
 
-  // the parsed JSON of a logical file (not cached: story documents are large and mostly per story), or null
-  doc(p, check) {
-    if (!this.has(p)) { this.err(p, "not in the manifest"); return null; }
-    this.checked.add(p);
-    let v;
-    try { v = JSON.parse(this.text(p)); } catch (e) { this.err(p, `not valid JSON (${e.message})`); return null; }
-    const errs = check ? check(v) : [];
-    for (const e of errs.slice(0, 20)) this.err(p, e);
-    return errs.length ? null : v;
+  readDoc(path, check = () => []) {
+    const r = this.json("story-document", path, (v) => ({ v, errs: check(v) }));
+    return r && !r.errs.length ? r.v : null;
   }
 
-  // every JSON file of the current file set not parsed by a check must parse
-  parseRest(paths) {
-    for (const p of paths) if (p.endsWith(".json") && !this.checked.has(p)) this.json("parse", p, () => ({ errs: [] }));
-  }
-
-  png(p, d, singleLevel) {
-    const asset = this.files[p].asset;
-    const info = this.site.once("png", asset, () => { try { return pngInfo(this.site.bytes(asset)); } catch (e) { return { error: e.message }; } });
-    if (info.error) { this.err(p, info.error); return; }
-    if (info.width !== d.width || info.height !== d.height)
-      this.err(p, `PNG is ${info.width}x${info.height}, descriptor ${d.name || ""} says ${d.width}x${d.height}`);
-    if (singleLevel && (d.mipCount ?? 1) !== 1) this.err(p, `descriptor ${d.name || ""}: mipCount ${d.mipCount}`);
-  }
-
-  // texture descriptors anywhere in a document: the ones whose PNG is in the file set (relative to `dir`) agree with it
-  descriptors(v, dir) {
-    const seen = new Set();
-    walk(v, (o) => {
-      if (!isDescriptor(o)) return;
-      const p = inDir(dir, o.texture), k = `${p}|${o.width}|${o.height}`;
-      if (seen.has(k) || !this.has(p)) return;       // described but not part of this story
-      seen.add(k);
-      this.png(p, desc(o), false);
-    });
+  part(path, identity) {
+    if (this.partCache.has(path)) {
+      const m = this.partCache.get(path);
+      if (m && (m.product !== identity.product || m.subject !== identity.subject)) {
+        this.err(path, `expected ${identity.product} product of ${identity.subject}`); return null;
+      }
+      return m;
+    }
+    let product;
+    try {
+      const m = JSON.parse(fs.readFileSync(this.site.file(path), "utf8"));
+      product = new Product(this.site, identity.subject, m, path);
+      for (const e of S.product(m)) product.err("manifest", e);
+      if (m.product !== identity.product || m.subject !== identity.subject)
+        product.err("manifest", `expected ${identity.product} product of ${identity.subject}`);
+      if (!product.errs.length) product.checkAssets();
+      for (const e of product.errs) this.err(path, e);
+    } catch (e) { this.err(path, e.message); }
+    const result = product && !product.errs.length ? product.man : null;
+    this.partCache.set(path, result);
+    return result;
   }
 
   run(entry) {
-    const m = this.man;
-    for (const e of S.storyManifest(m)) this.err("manifest", e);
-    if (!isObj(m.files) || !isObj(m.languages)) return this.errs;
-    this.checkGroups();
-    if (entry) this.crossCheck(entry);
+    for (const e of S.storyManifest(this.man)) this.err("manifest", e);
+    if (this.errs.length) return this.errs;
+    const root = "../".repeat(this.where.split("/").length - 1);
+    if ((this.man.root || "../") !== root) this.err("manifest", `root ${this.man.root || "../"}, expected ${root}`);
     this.checkAssets();
-    for (const [lang, g] of Object.entries(this.groups)) {
-      if (!isObj(g) || !isObj(g.files)) continue;
-      this.lang = lang; this.files = g.files;
-      this.checkAssets();
+    if (this.errs.length) return this.errs;
+    const story = this.readDoc("story.json", S.story), episode = this.readDoc("episode.json", S.episode);
+    if (!story || !episode) return this.errs;
+    if (String(story.advId) !== this.man.subject || episode.advId !== story.advId)
+      this.err("story.json", "story index, episode and product subject disagree");
+    if (episode.commands.length !== episode.commandCount) this.err("episode.json", "commandCount differs from the number of rows");
+    const languages = Object.keys(story.parts.ui);
+    if (!languages.length) this.err("story.json", "no UI language");
+    for (const name of ["fonts", ...(story.parts.simpleui ? ["simpleui"] : [])])
+      if (!sameJson(Object.keys(story.parts[name]).sort(), [...languages].sort())) this.err("story.json", `parts.${name}: languages differ from parts.ui`);
+    if (this.man.language && !languages.includes(this.man.language)) this.err("manifest", `default language ${this.man.language} not in parts.ui`);
+    if (entry) {
+      if (entry.id !== String(story.advId) || entry.advId !== story.advId) this.err("stories.json", "id differs from the story product");
+      if (entry.playbackMode !== (episode.master?._playbackMode || 0)) this.err("stories.json", "playbackMode differs from the episode");
+      if (!sameJson([...(entry.languages || [])].sort(), [...languages].sort())) this.err("stories.json", "languages differ from parts.ui");
     }
-    this.lang = null; this.files = this.common;
-    if (this.errs.length) return this.errs;       // content checks need every asset in place
-
-    const langs = Object.keys(this.groups);
-    if (!langs.length) { this.err("manifest", "no language group"); return this.errs; }
-    this.files = { ...this.common, ...this.groups[langs[0]].files };
-    const story = this.checkCommon();
-    if (story) {
-      this.parseRest(Object.keys(this.common));
-      for (const lang of langs) {
-        this.lang = lang;
-        this.files = { ...this.common, ...this.groups[lang].files };
-        this.checkLanguage(lang, story);
-        this.parseRest(Object.keys(this.groups[lang].files));
-      }
+    const dir = productDir(`stories/${story.advId}.json`);
+    const selected = this.site.storyLanguages || languages;
+    for (const lang of selected) {
+      this.lang = lang;
+      if (!languages.includes(lang)) { this.err("story.json", `no UI language ${lang}`); continue; }
+      try {
+        const requests = storyPartRequests(story, lang), loaded = [[dir, this.man]];
+        for (const [path, identity] of requests) {
+          const m = this.part(path, identity);
+          if (m) loaded.push([productDir(path), m]);
+        }
+        if (loaded.length !== requests.size + 1) continue;
+        const merged = mergeProductManifests(loaded);
+        const store = new SiteStore(this.site, merged.files, merged.objects, { ...merged, loadedLanguage: lang });
+        const data = new StoryData(store), objects = new ObjectResources(store, data.resourceOptions());
+        const checks = new LiveChecks(this.site, store, (w, m) => this.err(w, m));
+        this.store = store; this.data = data; this.objectsView = objects; this.checks = checks;
+        this.checkParts(requests);
+        checks.objects({ selectedPrograms: true, materialKeywords: this.materialKeywords() });
+        this.checkEpisode();
+        this.checkFonts(data.fonts, data.ui);
+        this.checkModels();
+        if (entry?.commands) {
+          const commands = StoryPlayerCore.requiredCommands(episode, data.playerSettings).sort();
+          if (!sameJson([...entry.commands].sort(), commands)) this.err("stories.json", "commands differ from the episode and player settings");
+        }
+      } catch (e) { this.err("story", e.message); }
     }
-    this.lang = null; this.files = this.common;
+    this.lang = null;
     return this.errs;
   }
 
-  checkGroups() {
-    const m = this.man;
-    // root: the site root seen from the manifest (stories/<advId>.json, stories/<region>/<advId>.json)
-    if (this.where) {
-      const root = "../".repeat(this.where.split("/").length - 1);
-      if (m.root !== root) this.err("manifest", `root ${JSON.stringify(m.root)}, the site root from ${this.where} is ${JSON.stringify(root)}`);
-    }
-    // the store the player builds: the common files, one group and each model's model.json under live2d/<id>/
-    for (const [where, files] of [["files", m.files], ...Object.entries(m.languages).map(([l, g]) => [`languages.${l}`, isObj(g) ? g.files : null])])
-      for (const p of Object.keys(isObj(files) ? files : {}))
-        if (p.startsWith("live2d/")) this.err("manifest", `${where}: ${p}: live2d/ holds the files of the models (manifest models)`);
-    if (!has(m.languages, m.language)) this.err("manifest", `language ${m.language} is not a key of languages`);
-    for (const [lang, g] of Object.entries(m.languages)) {
-      if (!isObj(g) || !isObj(g.files)) continue;
-      for (const p of Object.keys(g.files)) if (has(m.files, p)) this.err("manifest", `languages.${lang}: ${p} is also a common file`);
-      for (const p of ["ui/fonts.json", "ui/languages.json"]) if (!has(g.files, p)) this.err("manifest", `languages.${lang}: ${p} missing`);
-      if (isObj(m.host) && !has(g.files, "ui/simple/fonts.json")) this.err("manifest", `languages.${lang}: ui/simple/fonts.json missing (the story has a host)`);
+  checkParts(requests) {
+    const C = this.checks, data = this.data, objects = this.objectsView;
+    for (const [path, { product }] of requests) {
+      const spec = STORY_DOCS[product];
+      if (!spec) continue;
+      const [file, check] = spec, where = `${productDir(path)}/${file}`, doc = C.doc(where, S[check]);
+      if (!doc) continue;
+      if (doc.bindings) C.tables(where, doc);
+      for (const [key, cls] of Object.entries(STORY_REFS[product] || {})) {
+        const value = doc[key];
+        for (const id of typeof value === "string" ? [value] : Array.isArray(value) ? value : Object.values(value || {}))
+          if (cls === "GameObject") C.prefab(id, `${where} ${key}`); else C.object(id, cls, `${where} ${key}`);
+      }
+      for (const [key, id] of Object.entries(doc.settings || {})) {
+        if (this.store.hasObject(id)) C.object(id, "MonoBehaviour", `${where} settings.${key}`);
+        else {
+          const cut = id.lastIndexOf(":"), ref = { $ref: { file: id.slice(0, cut), pathId: id.slice(cut + 1) } };
+          try { if (this.store.contained(ref).component?.type !== "MonoBehaviour") this.err(where, `settings.${key}: not a MonoBehaviour`); }
+          catch (e) { this.err(where, `settings.${key}: ${e.message}`); }
+        }
+      }
+      for (const [key, id] of Object.entries(doc.graphics || {})) C.object(id, GRAPHICS_CLASSES[key], `${where} graphics.${key}`);
+      if (doc.language) {
+        if (doc.language.code !== this.lang || doc.language.field !== STORY_LANGUAGES[this.lang][1] || doc.language.mode !== STORY_LANGUAGES[this.lang][0]) this.err(where, "language code/field differs from selected language");
+        for (const id of Object.keys(doc.texts || {})) if (!has(data.fonts.texts, id)) this.err(where, `text ${id} has no font binding`);
+      }
+      if (product === "story.asset") {
+        if (doc.key !== this.partCache.get(path).subject) this.err(where, "key differs from product subject");
+        for (const id of doc.objects) if (!this.store.hasObject(id)) this.err(where, `object ${id} missing`);
+      }
+      if (product === "story.host") {
+        const node = (ref) => {
+          if (!C.object(ref.prefab, "GameObject", where)) return;
+          const prefab = objects.prefab(ref.prefab);
+          if (!prefab.nodes.has(ref.path)) this.err(where, `node ${ref.path} not in ${ref.prefab}`);
+        };
+        for (const ref of [doc.overlayRoot, doc.layoutRoot, ...doc.openedSequences]) node(ref);
+        if (doc.kind !== data.story.host?.kind) this.err(where, "kind differs from the episode host");
+        if (doc.kind === "home") {
+          if (!doc.home) { this.err(where, "home settings missing"); continue; }
+          for (const key of ["background", "situation"]) C.prefab(doc.home[key], `${where} home.${key}`);
+          for (const [key, names] of [["room", "rooms"], ["spot", "spots"]])
+            if (!Object.values(data.parts[names] || {}).includes(doc.home.parts[key])) this.err(where, `home.parts.${key} not in story.parts.${names}`);
+        } else if (!doc.afterlive) this.err(where, "afterlive settings missing");
+        else { node(doc.afterlive.rewardPanel); node(doc.afterlive.backgroundImage); C.sprite(doc.afterlive.backgroundSprite, where); }
+      }
     }
-    if (!isObj(m.story)) return;
-    const s = m.story;
-    if (s.advId !== m.advId) this.err("manifest", `story.advId ${s.advId}, advId ${m.advId}`);
-    if (s.language !== m.language) this.err("manifest", `story.language ${s.language}, language ${m.language}`);
-    if (!sameJson([...(s.languages || [])].sort(), Object.keys(m.languages).sort())) this.err("manifest", "story.languages differ from the keys of languages");
-    if (isObj(m.requires) && !sameJson(m.requires.commands, s.commands)) this.err("manifest", "requires.commands differ from story.commands");
   }
 
-  crossCheck(e) {
-    const m = this.man;
-    if (e.id !== String(m.advId)) this.err("stories.json", `id ${e.id}, manifest advId ${m.advId}`);
-    for (const k of ["audio", "audioFormat", "fonts"]) if (e[k] !== m[k]) this.err("stories.json", `${k} ${JSON.stringify(e[k])}, manifest ${JSON.stringify(m[k])}`);
-    if (isObj(m.story)) for (const [k, v] of Object.entries(m.story)) if (!sameJson(e[k], v)) this.err("stories.json", `${k} differs from the manifest's story.${k}`);
-    if ((has(e, "regions") || has(m, "regions")) && !sameJson(e.regions, m.regions)) this.err("stories.json", "regions differ from the manifest");
-    const size = { common: sizeOf(m.files), models: this.modelsSize(),
-                   languages: Object.fromEntries(Object.entries(this.groups).map(([l, g]) => [l, sizeOf(g.files || {})])) };
-    if (size.models !== null && !sameJson(e.size, size)) this.err("stories.json", `size ${JSON.stringify(e.size)}, manifest files ${JSON.stringify(size)}`);
-  }
-
-  // the sum of size over the files of the listed model manifests and of their objects, an object several of them list
-  // counted once (null while one of them is missing or unreadable)
-  modelsSize() {
-    const files = {};
-    for (const [id, p] of Object.entries(isObj(this.man.models) ? this.man.models : {})) {
-      const r = p === `models/${id}.json` ? this.site.model(id, p) : null;
-      if (!r || !r.model) return null;
-      for (const [k, f] of Object.entries(r.model.files)) files[k.includes("#") ? k : `${id}/${k}`] = f;
+  checkEpisode() {
+    const d = this.data, e = d.episode, C = this.checks;
+    const names = StoryPlayerCore.requiredCommands(e, d.playerSettings);
+    const unsupported = e.master?._playbackMode === 1 ? simpleUnsupportedCommands(names)
+      : names.filter((n) => !StoryPlayerCore.supportedCommands().includes(n));
+    if (unsupported.length) this.err("episode.json", `unsupported commands: ${unsupported.join(", ")}`);
+    if (e.master?._playbackMode === 1 && !d.simpleui) this.err("story.json", "Overlay episode requires parts.simpleui");
+    if (d.story.host && !d.host) this.err("story.json", "episode host has no host product");
+    for (const row of e.commands) if (!row.IgnoreData && row.cmd === "Character") {
+      const address = `Character/Live2D/${row.TargetAssetName}`;
+      if (!d.parts.models[address]) this.err("episode.json", `row ${row.i}: model ${address} not in parts.models`);
+    }
+    for (const [id, row] of Object.entries(e.sounds)) {
+      const sheet = e.cuesheets[row._soundCueSheetID]?._cueSheetName;
+      if (!sheet || !d.parts.sounds[sheet]) this.err("episode.json", `sound ${id}: cue sheet not in parts.sounds`);
+      else if (!d.cues(sheet)[row._cueName]) this.err("episode.json", `sound ${id}: cue ${row._cueName} not in ${sheet}`);
+    }
+    for (const [sheet, path] of Object.entries(d.parts.sounds)) for (const [name, cue] of Object.entries(d.cues(sheet))) {
+      const where = `${productDir(path)}/cues.json ${name}`;
+      if (!Number.isInteger(cue.sampleRate) || !Number.isInteger(cue.samples) || !(cue.sampleRate > 0) || cue.samples < 0) { this.err(where, "invalid sampleRate/samples"); continue; }
+      if (!Array.isArray(cue.categories) || cue.categories.some((c) => typeof c !== "string")) this.err(where, "categories must be an array of names");
+      if ((cue.loopStart == null) !== (cue.loopEnd == null) || (cue.loopStart != null && !(cue.loopStart >= 0 && cue.loopStart < cue.loopEnd && cue.loopEnd <= cue.samples))) this.err(where, "loop points outside the waveform");
+      if (cue.encoderDelay !== undefined && (extOf(cue.file) !== "m4a" || !Number.isInteger(cue.encoderDelay) || cue.encoderDelay < 0)) this.err(where, "invalid encoderDelay");
+      if (!this.store.has(cue.file)) this.err(where, `${cue.file} missing`);
+      else { const error = C.ofFile(`story-wave|${cue.sampleRate}|${cue.samples}|${cue.channels}`, cue.file, (b) => waveCheck(b, cue)); if (error) this.err(where, error); }
+    }
+    if (d.parts.crilips) {
+      const { descriptor: desc, data } = d.crilips, floats = data.byteLength / 4;
+      if (desc.dtype !== "float32" || desc.order !== "LE") this.err("crilips.json", "expected float32 LE");
+      if (floats !== desc.total_floats) this.err("crilips.bin", `length ${floats} differs from total_floats ${desc.total_floats}`);
+      for (const block of desc.blocks || []) if (!Number.isInteger(block.offset) || !Number.isInteger(block.count) || block.offset < 0 || block.count < 0 || block.offset + block.count > floats)
+        this.err("crilips.json", `block ${block.name} outside weights`);
+      if (!Array.isArray(desc.blocks) || !isObj(desc.constants) || !isObj(desc.frontend)) this.err("crilips.json", "blocks/constants/frontend missing");
+    }
+    for (const [id, row] of Object.entries(e.videos)) if (row._assetName?.trim()) {
+      try { const v = d.videoFor(id); if (!this.store.has(v.file)) this.err("video.json", `${v.file} missing`); } catch (error) { this.err("episode.json", error.message); }
     }
-    return sizeOf(files);
   }
 
-  // the files every language shares: story.json, episode.json, scene.json, commands, sounds, models, shaders, textures
-  // a shader directory: its index, the parsed shader files, the GLSL stage blocks of every program
-  checkShaders(dir) {
-    const idx = `${dir}/shaders.json`;
-    const r = this.json("shaders", idx, (list) => {
-      const errs = [];
-      if (!Array.isArray(list)) return { errs: ["not an array"] };
-      const names = new Set();
-      for (const [i, rec] of list.entries()) {
-        if (!isObj(rec) || typeof rec.name !== "string" || typeof rec.parsed !== "string" || !Array.isArray(rec.variants)) { errs.push(`[${i}]: needs name, parsed, variants`); continue; }
-        if (names.has(rec.name)) errs.push(`shader ${rec.name} twice`);
-        names.add(rec.name);
-        for (const v of rec.variants)
-          if (!isObj(v) || typeof v.file !== "string" || !Number.isInteger(v.subShader) || !Number.isInteger(v.pass) || !Array.isArray(v.keywords))
-            errs.push(`${rec.name}: a variant needs file, subShader, pass, keywords`);
-      }
-      return { errs, list: errs.length ? [] : list.map((x) => ({ name: x.name, parsed: x.parsed, files: x.variants.map((v) => v.file) })) };
-    });
-    if (!r || r.errs.length) return;
-    for (const rec of r.list) {
-      const pp = `${dir}/${rec.parsed}`;
-      this.json("shaderinfo", pp, (s) => ({ errs: parsedShaderErrors(s) }));
-      for (const f of rec.files) {
-        const fp = `${dir}/${f}`;
-        if (!this.has(fp)) { this.err(idx, `${rec.name}: ${fp} not in the manifest`); continue; }
-        if (!fp.endsWith(".glsl")) { this.err(fp, "a variant file must be .glsl"); continue; }
-        const errs = this.site.once("glsl", this.files[fp].asset, () => glslStages(this.text(fp)));
-        for (const e of errs) this.err(fp, e);
+  // The home camera contributes its pipeline's lighting keywords to the room and Spine materials at each quality.
+  materialKeywords() {
+    const data = this.data, objects = this.objectsView, result = new Map();
+    if (data.host?.kind !== "home") return result;
+    const scene = new HomeScene(data, objects), home = data.host.home, graphics = data.scene.graphics;
+    const hostManifest = this.partCache.get(Object.values(data.parts.host)[0]);
+    // The host retains the prefab dependency graph. Only room renderers and selected UI subtrees are drawn.
+    for (const [id, object] of Object.entries(hostManifest.objects)) if (object.class === "Material") result.set(id, []);
+    const ui = new SimpleUIDoc(null, null, data.host, { objects, roots: hostUIRoots(data.host, objects) });
+    for (const [id, material] of ui.uiMaterials) if (this.store.hasObject(id)) result.set(id, [material.keywords || []]);
+    const materials = new Map(data.document(home.parts.room, "room.json").materialIds.map((id) => [id, objects.material(id)]));
+    const spot = data.document(home.parts.spot, "spot.json");
+    for (const c of spot.spineCharacters) if (c.skeletonData && c.animation && c.world)
+      for (const m of scene.spine(c.path).pages.values()) materials.set(m.id, m);
+    for (const quality of this.store.objectJson(graphics.quality).m_QualitySettings) {
+      const pipeline = objects.mono(quality.customRenderPipeline || this.store.objectJson(graphics.graphics).m_CustomRenderPipeline);
+      const renderer = objects.mono(pipeline.m_RendererDataList[0]);
+      const lighting = spotLighting({ pipeline, renderer: { ...renderer, m_RendererFeatures: renderer.m_RendererFeatures.map((id) => objects.mono(id)) },
+        renderSettings: scene.renderSettings, lights: scene.lights, lightmaps: scene.lightmaps });
+      for (const [id, m] of materials) {
+        if (!result.has(id)) result.set(id, []);
+        result.get(id).push([...(m.keywords || []), ...lighting.keywords]);
       }
     }
+    return result;
   }
 
-  checkCommon() {
-    const m = this.man;
-    const story = this.doc("story.json", S.story);
-    if (!story) return null;
-    if (story.advId !== m.advId) this.err("story.json", `advId ${story.advId}, manifest ${m.advId}`);
-    for (const p of [story.episode, story.scene, ...STORY_MEDIA.map((k) => story[k]).filter((p) => p !== null)])
-      if (!has(this.common, p)) { this.err("story.json", `${p} is not a common file`); return null; }
-    const episode = this.doc(story.episode, S.episode);
-    const scene = this.doc(story.scene, (v) => (isObj(v) && isObj(v.settings) && isObj(v.settings.playerSettings) ? [] : ["settings.playerSettings missing"]));
-    if (!episode || !scene) return null;
-    const s = isObj(m.story) ? m.story : {};
-    if (episode.advId !== m.advId) this.err(story.episode, `advId ${episode.advId}, manifest ${m.advId}`);
-    if (episode.commandCount !== episode.commands.length) this.err(story.episode, `commandCount ${episode.commandCount}, ${episode.commands.length} rows`);
-    if (s.commandCount !== episode.commandCount) this.err("manifest", `story.commandCount ${s.commandCount}, episode ${episode.commandCount}`);
-    if (isObj(episode.master) && s.playbackMode !== episode.master._playbackMode) this.err("manifest", `story.playbackMode ${s.playbackMode}, episode master row ${episode.master._playbackMode}`);
-
-    // the commands the player runs: the rows without IgnoreData, the player settings' initialize and finalize rows
-    const ps = scene.settings.playerSettings, names = new Set();
-    for (const c of episode.commands) if (!truthy(c.IgnoreData)) names.add(c.cmd);
-    for (const k of ["_initializeEpisodes", "_finalizeEpisodes"]) for (const r of ps[k] || []) names.add(commandName(r.Command));
-    const want = [...names].sort();
-    if (!sameJson(m.requires.commands, want)) this.err("manifest", `requires.commands ${JSON.stringify(m.requires.commands)}, the episode runs ${JSON.stringify(want)}`);
-    const lipSync = episode.commands.some((c) => c.cmd === "Talk" && truthy(c.TargetName) && truthy(c.VoiceIDs) && !truthy(c.IgnoreLipSync) && !truthy(c.IgnoreData));
-    if (m.requires.motionSync !== lipSync) this.err("manifest", `requires.motionSync ${m.requires.motionSync}, the episode ${lipSync ? "has" : "has no"} lip-synced Talk rows`);
-
-    this.checkSounds(story, episode);
-    const models = this.checkModels(story, episode);
-    if (this.has("shaders/shaders.json")) this.checkShaders("shaders");
-    else if (models.length) this.err("shaders/shaders.json", "not in the manifest");
-    this.descriptors(scene, "");
-    this.frameTexts = {};
-    for (const k of STORY_MEDIA) if (story[k] !== null && k !== "videos") {
-      const v = this.doc(story[k]);
-      if (v) this.descriptors(v, "");
-      if (v) for (const e of animRecordProblems(v)) this.err(story[k], e);
-      if (v && k === "frames") this.frameTexts = frameTextNodes(v);
-    }
-    if (this.has("ui/shaders/shaders.json")) this.checkShaders("ui/shaders");
-    else this.err("ui/shaders/shaders.json", "not in the manifest");
-    this.checkHost();
-    this.checkCriLips(story);
-    return story;
-  }
-
-  // the CRI Lips data (story.json crilips, docs/crilips.md): both files common, a float32 LE descriptor whose blocks lie
-  // inside the weights file, in a story with audio
-  checkCriLips(story) {
-    const c = story.crilips;
-    if (c === undefined || c === null) return;
-    if (this.man.audio === false) this.err("story.json", "crilips in a story without audio");
-    for (const p of [c.descriptor, c.data]) if (!has(this.common, p)) { this.err("story.json", `crilips ${p} is not a common file`); return; }
-    const d = this.doc(c.descriptor, (v) => (isObj(v) && Array.isArray(v.blocks) && isObj(v.constants) && isObj(v.frontend)
-      ? [] : ["not a CRI Lips descriptor (blocks, constants, frontend)"]));
-    if (!d) return;
-    if (d.dtype !== "float32" || d.order !== "LE") this.err(c.descriptor, `dtype ${d.dtype}, order ${d.order}: expected float32 LE`);
-    const floats = this.common[c.data].size / 4;
-    if (floats !== d.total_floats) this.err(c.data, `${this.common[c.data].size} bytes, the descriptor has ${d.total_floats} floats`);
-    for (const b of d.blocks)
-      if (!(Number.isInteger(b.offset) && Number.isInteger(b.count) && b.offset >= 0 && b.offset + b.count <= floats))
-        this.err(c.descriptor, `block ${b.name} [${b.offset}, +${b.count}) outside the ${floats} floats`);
-  }
-
-  // the host of an Overlay story: present exactly for playbackMode 1 with open fonts, host.json common, its kind
-  checkHost() {
-    const m = this.man, s = isObj(m.story) ? m.story : {}, host = m.host;
-    const overlay = s.playbackMode === 1;
-    if (!isObj(host)) {
-      if (overlay && m.fonts === "open") this.err("manifest", "an Overlay story (playbackMode 1) with open fonts has no host");
-      return;
+  checkModels() {
+    for (const [key, path] of Object.entries(this.data.parts.models)) {
+      const id = key.split("/").at(-1), result = this.site.model(id, path);
+      if (this.site.modelIds && !this.site.modelIds.has(id)) this.err(path, `model ${id} not in models.json`);
+      for (const e of result.errs) this.err(path, e);
     }
-    if (!overlay) { this.err("manifest", `host on a story of playbackMode ${s.playbackMode}`); return; }
-    if (m.fonts !== "open") this.err("manifest", `host on a story with ${m.fonts} fonts`);
-    if (!has(this.common, host.doc)) { this.err("manifest", `host.doc ${host.doc} is not a common file`); return; }
-    const doc = this.doc(host.doc, (v) => (isObj(v) ? [] : ["not an object"]));
-    if (!doc) return;
-    if (doc.format !== STORY_HOST_FORMAT) this.err(host.doc, `format ${JSON.stringify(doc.format)}, expected ${STORY_HOST_FORMAT}`);
-    if (doc.kind !== host.kind) this.err(host.doc, `kind ${doc.kind}, manifest host.kind ${host.kind}`);
-    if (typeof doc.ui === "string" && !has(this.common, doc.ui)) this.err(host.doc, `ui ${doc.ui} is not a common file`);
   }
 
-  checkSounds(story, episode) {
-    const m = this.man, sheets = story.audio;
-    if (m.audio === false) {
-      if (Object.keys(sheets).length) this.err("story.json", "audio is not empty in a story without audio");
-      for (const p of Object.keys(this.common)) if (/\.(m4a|flac)$/.test(p)) this.err(p, "a waveform file in a story without audio");
-      return;
+  checkFonts(fonts, ui) {
+    const F = `${this.data.fontDir}/fonts.json`, C = this.checks, S = this.store;
+    const schemaErrors = C.doc(F, SCHEMA_STORY_FONTS);
+    if (!schemaErrors) return;
+    if (fonts.language !== this.lang) this.err(F, `language ${fonts.language}`);
+    const texts = new Map();
+    for (const id of S.ids()) if (S.object(id).class === "GameObject") {
+      const pf = S.prefab(id), file = id.slice(0, id.lastIndexOf(":"));
+      for (const node of pf.nodes) for (const component of node.components)
+        if (TMP_TEXT_CLASSES.has(classOf(component))) texts.set(`${file}:${component.pathId}`, component);
     }
-    for (const cs of Object.values(episode.cuesheets || {}))
-      if (isObj(cs) && !has(sheets, cs._cueSheetName)) this.err("story.json", `cue sheet ${cs._cueSheetName} of the episode has no audio directory`);
-    for (const [name, dir] of Object.entries(sheets)) {
-      const cp = `${dir}/cues.json`;
-      if (!has(this.common, cp)) { this.err("story.json", `audio.${name}: ${cp} is not a common file`); continue; }
-      const cues = this.doc(cp, (v) => (isObj(v) ? [] : ["not an object"]));
-      if (!cues) continue;
-      for (const [cue, c] of Object.entries(cues)) {
-        if (!isObj(c) || typeof c.file !== "string" || !Number.isInteger(c.sampleRate) || !Number.isInteger(c.samples)) { this.err(cp, `${cue}: needs file, sampleRate, samples`); continue; }
-        if (extOf(c.file) !== WAVE_EXT[m.audioFormat]) this.err(cp, `${cue}: ${c.file} does not match audioFormat ${m.audioFormat}`);
-        if ((c.loopStart === undefined) !== (c.loopEnd === undefined)) this.err(cp, `${cue}: loopStart and loopEnd must both be set or both absent`);
-        else if (c.loopStart !== undefined && !(c.loopStart < c.loopEnd && c.loopEnd <= c.samples)) this.err(cp, `${cue}: loop points outside the waveform`);
-        if (c.encoderDelay !== undefined && (extOf(c.file) !== "m4a" || !Number.isInteger(c.encoderDelay) || c.encoderDelay < 0)) this.err(cp, `${cue}: encoderDelay ${c.encoderDelay}`);
-        const p = `${dir}/${c.file}`;
-        if (!has(this.common, p)) { this.err(cp, `${cue}: ${p} is not a common file`); continue; }
-        const asset = this.files[p].asset;
-        const e = this.site.once("wave", `${asset}|${c.sampleRate}|${c.channels}|${c.samples}`, () => {
-          const b = this.site.bytes(asset);
-          if (extOf(p) === "m4a") return isMp4(b) ? null : "not an MP4 file";
-          try {
-            const i = flacInfo(b);
-            if (i.sampleRate !== c.sampleRate) return `FLAC sample rate ${i.sampleRate}, described ${c.sampleRate}`;
-            if (c.channels !== undefined && i.channels !== c.channels) return `FLAC channels ${i.channels}, described ${c.channels}`;
-            if (i.samples !== c.samples) return `FLAC total samples ${i.samples}, described ${c.samples}`;
-            return null;
-          } catch (err) { return err.message; }
-        });
-        if (e) this.err(p, e);
-      }
+    for (const [id, binding] of Object.entries(fonts.texts)) {
+      if (!texts.has(id)) this.err(F, `text ${id} is not a TMP component of the story's prefabs`);
+      const loc = binding.font;
+      if (!has(fonts.fonts, loc.fontAsset)) this.err(F, `text ${id}: font asset ${loc.fontAsset} not in fonts`);
+      if (!has(fonts.materials, loc.material)) this.err(F, `text ${id}: material ${loc.material} not in materials`);
+      this.fallbackMaterials(F, loc, fonts);
     }
-  }
-
-  // the Live2D models (story.json models: address -> id; the manifest's models: id -> models/<id>.json): the same ids
-  // in both, keys sorted, each Character row's model among them, each model manifest present (listed in models.json
-  // when the site has one) and valid as a model (with the programs the story renderer draws its materials with at
-  // every quality). Returns the valid models.
-  checkModels(story, episode) {
-    const m = this.man, listed = isObj(m.models) ? m.models : {}, out = [];
-    const ids = Object.keys(listed);
-    if (ids.some((k, i) => i > 0 && k <= ids[i - 1])) this.err("manifest", "models: keys not sorted");
-    for (const [address, id] of Object.entries(story.models))
-      if (typeof id !== "string") this.err("story.json", `models.${address}: not a model id`);
-      else if (!has(listed, id)) this.err("story.json", `models.${address}: model ${id} is not in the manifest's models`);
-    const named = new Set(Object.values(story.models));
-    for (const id of ids) if (!named.has(id)) this.err("manifest", `models.${id}: no model address of story.json names it`);
-    const rows = new Set();
-    for (const c of episode.commands) {
-      if (c.cmd !== "Character" || truthy(c.IgnoreData)) continue;
-      const address = `Character/Live2D/${c.TargetAssetName}`;
-      if (!has(story.models, address) && !rows.has(address)) this.err(story.episode, `row ${c.i}: model ${address} is not in story.json models`);
-      rows.add(address);
+    for (const [name, tex] of Object.entries(fonts.textures)) {
+      const path = `${this.data.fontDir}/${tex.texture}`;
+      if (!S.has(path)) { this.err(F, `texture ${name}: ${path} missing`); continue; }
+      const info = C.ofFile("png", path, (b) => { try { return pngInfo(b); } catch (e) { return { error: e.message }; } });
+      if (info.error) this.err(path, info.error);
+      else if (info.width !== tex.width || info.height !== tex.height || tex.mipCount !== 1) this.err(path, "glyph page dimensions/mip count differ from descriptor");
     }
-    for (const [id, p] of Object.entries(listed)) {
-      if (p !== `models/${id}.json`) { this.err("manifest", `models.${id}: ${p}, expected models/${id}.json`); continue; }
-      if (this.site.modelIds && !this.site.modelIds.has(id)) this.err("manifest", `models.${id}: not in models.json`);
-      const r = this.site.model(id, p);
-      if (r.missing) { this.err("manifest", `models.${id}: ${p} missing`); continue; }
-      if (r.errs.length) {
-        this.err(p, `not a valid model (${r.errs.length} problem${r.errs.length > 1 ? "s" : ""}): ${r.errs.slice(0, 3).join("; ")}`);
-        continue;
-      }
-      out.push(r.model);
+    const shaderIndex = Object.entries(fonts.shaders).map(([name, id]) => ({ name, variants: S.objectJson(id, "index").variants.filter((v) => v.platform === "gles3" && v.type === "GLES3" && v.stage === "vertex") }));
+    for (const [name, mat] of Object.entries(fonts.materials)) {
+      if (!has(fonts.materialKeywords, name)) this.err(F, `material ${name}: no materialKeywords`);
+      const selected = variantFor(shaderIndex, mat.shader.shader, fonts.materialKeywords[name] || []);
+      if (selected.error) this.err(F, `material ${name}: ${selected.error}`);
+      else if (!S.roles(fonts.shaders[mat.shader.shader]).includes(selected.variant.role)) this.err(F, `material ${name}: selected shader program missing`);
+      else for (const error of C.ofObject("glsl", fonts.shaders[mat.shader.shader], selected.variant.role, (b) => glslStages(b.toString("utf8")))) this.err(F, `material ${name}: ${error}`);
+    }
+    for (const name of Object.keys(fonts.materialKeywords)) if (!has(fonts.materials, name)) this.err(F, `materialKeywords.${name}: not in materials`);
+    const tmp = this.objectsView.mono(ui.settings.tmpSettings);
+    for (const [name, font] of Object.entries(fonts.fonts)) {
+      const where = `${F} fonts.${name}`;
+      if (!has(fonts.materials, font.material)) this.err(where, `material ${font.material} not in materials`);
+      for (const f of font.fallbacks) if (!has(fonts.fonts, f)) this.err(where, `fallback ${f} not in fonts`);
+      if (font.fallbacks.includes(name) || new Set(font.fallbacks).size !== font.fallbacks.length) this.err(where, "fallbacks list the asset itself or an asset twice");
+      for (const [u, char] of Object.entries(font.characters)) if (!has(font.glyphs, char.glyph)) this.err(where, `character ${u}: glyph ${char.glyph} not in glyphs`);
+      this.glyphPages(where, font.glyphs, fonts.textures);
+      if (font.missingGlyph) this.missingGlyph(where, font, { ...fonts, tmpSettings: tmp });
+    }
+    const substituted = [...new Set(Object.values(fonts.fonts).flatMap((f) => f.missingGlyph?.characters || []))].sort((a,b) => a-b).map((u) => String.fromCodePoint(u));
+    if (!sameJson(fonts.coverage.missingGlyph || [], substituted)) this.err(F, "coverage.missingGlyph differs from the font assets' missingGlyph characters");
+    for (const [name, asset] of Object.entries(fonts.spriteAssets || {})) {
+      if (!has(fonts.materials, asset.material)) this.err(F, `sprite asset ${name}: material ${asset.material} not in materials`);
+      else if (fonts.materials[asset.material].shader.shader !== TMP_SPRITE_SHADER) this.err(F, `sprite asset ${name}: material is not TextMeshPro/Sprite`);
+      this.glyphPages(`${F} spriteAssets.${name}`, asset.glyphs, fonts.textures);
+      for (const char of asset.characters) if (!has(asset.glyphs, char.glyph)) this.err(F, `sprite ${char.name}: glyph ${char.glyph} missing`);
+    }
+    for (const [id, binding] of Object.entries(fonts.sprites)) {
+      if (!has(fonts.texts, id)) this.err(F, `sprites.${id}: no text binding`);
+      if (!has(fonts.spriteAssets || {}, binding.spriteAsset) || binding.spriteAsset !== fonts.emojiSpriteAsset) this.err(F, `sprites.${id}: not the emoji sprite asset`);
+      if (texts.has(id) && texts.get(id).fields.m_tintAllSprites === undefined) this.err(F, `sprites.${id}: TMP component has no m_tintAllSprites`);
+    }
+    if (fonts.coverage.sprites) {
+      const all = Object.values(fonts.spriteAssets || {}).flatMap((a) => a.characters.map((c) => [c, a.glyphs[c.glyph]]));
+      if (fonts.coverage.sprites.characters !== all.length) this.err(F, "coverage.sprites.characters differs from sprite assets");
+      for (const name of fonts.coverage.sprites.missing) if (!all.some(([c,g]) => c.name === name && !g?.packed)) this.err(F, `coverage.sprites.missing: ${name} is not a missing sprite`);
     }
-    return out;
   }
 
-  // one language: ui/ui.json, ui/languages.json, ui/fonts.json
-  checkLanguage(lang, story) {
-    const m = this.man;
-    const ui = this.doc(story.ui, (v) => {
-      if (!isObj(v) || !Array.isArray(v.nodes)) return ["nodes is not an array"];
-      if (!v.nodes.every((n) => isObj(n) && typeof n.path === "string")) return ["a node needs path"];
-      // every parent that is a node of the list comes before its children (the canvases' parent is not listed)
-      const all = new Set(v.nodes.map((n) => n.path)), seen = new Set();
-      for (const n of v.nodes) {
-        const cut = n.path.lastIndexOf("/");
-        if (cut >= 0 && all.has(n.path.slice(0, cut)) && !seen.has(n.path.slice(0, cut))) return [`parent of ${n.path} is not listed before it`];
-        seen.add(n.path);
-      }
-      return [];
-    });
-    const lj = this.doc("ui/languages.json", S.storyLanguage);
-    const fj = this.doc("ui/fonts.json", S.storyFonts);
-    if (!ui || !lj || !fj) return;
-    this.descriptors(ui, "ui");
-    let uiShaders = null;
-    if (this.has("ui/shaders/shaders.json")) try { uiShaders = JSON.parse(this.text("ui/shaders/shaders.json")); } catch { uiShaders = null; }
-    const shaderOf = (where, mats, keywords) => {
-      for (const [n, mat] of Object.entries(mats || {})) {
-        const sh = isObj(mat) && isObj(mat.shader) ? mat.shader.shader : null;
-        if (typeof sh !== "string") { this.err(where, `material ${n} names no shader`); continue; }
-        if (!Array.isArray(uiShaders)) continue;
-        const kw = isObj(keywords) && Array.isArray(keywords[n]) ? keywords[n] : null;
-        if (!kw) { this.err(where, `material ${n} has no materialKeywords`); continue; }
-        const v = variantFor(uiShaders, sh, kw);
-        if (v.error) this.err(where, `material ${n}: ui/shaders/shaders.json: ${v.error}`);
-      }
-    };
-    shaderOf(story.ui, ui.materials, ui.materialKeywords);
-
-    const [mode, field] = STORY_LANGUAGES[lang] || [];
-    if (lj.language !== lang) this.err("ui/languages.json", `language ${lj.language}`);
-    if (lj.mode !== mode || lj.field !== field) this.err("ui/languages.json", `mode ${lj.mode} / field ${lj.field}, ${lang} is ${mode} / ${field}`);
-    if (lj.fonts !== m.fonts) this.err("ui/languages.json", `fonts ${lj.fonts}, manifest ${m.fonts}`);
-    for (const [role, r] of Object.entries(lj.roles)) if (!has(fj.fonts, r.fontAsset)) this.err("ui/languages.json", `roles.${role}: font asset ${r.fontAsset} not in ui/fonts.json`);
-
-    this.checkFonts("ui/fonts.json", fj, ui, story.ui, "ui", lang, shaderOf);
-    // the dialog, chat window and frame texts: with open fonts a binding per text node of ui.json dialogs (fonts.json
-    // dialogTexts), per text of ui.json chatTexts (fonts.json chatTexts) and per text node of the frames of
-    // frames.json (fonts.json frameTexts)
-    const F = "ui/fonts.json";
-    const dialogs = {};
-    for (const [d, rec] of Object.entries(isObj(ui.dialogs) ? ui.dialogs : {}))
-      dialogs[d] = Object.fromEntries((Array.isArray(rec.nodes) ? rec.nodes : []).filter((n) => has(n, "textStyle")).map((n) => [n.path, n]));
-    const groups = [["dialogTexts", "dialog", dialogs, `${story.ui} dialogs`],
-                    ["chatTexts", "chat window", isObj(ui.chatTexts) ? ui.chatTexts : {}, `${story.ui} chatTexts`],
-                    ["frameTexts", "frame", this.frameTexts || {}, `${story.frames || "frames.json"} frames`]];
-    for (const [key, what, wanted, source] of groups) {
-      if (m.fonts !== "open") {
-        if (has(fj, key)) this.err(F, `${key} in ${m.fonts}-font data`);
-        continue;
-      }
-      const bound = isObj(fj[key]) ? fj[key] : {};
-      for (const [w, texts] of Object.entries(wanted)) for (const p of Object.keys(texts)) if (!has(bound[w], p)) this.err(F, `${what} ${w}: text ${p} has no binding in ${key}`);
-      for (const [w, texts] of Object.entries(bound)) for (const [p, t] of Object.entries(texts)) {
-        if (!has(wanted[w], p)) this.err(F, `${key}.${w}.${p}: not a text of ${source}`);
-        this.binding(F, `${key}.${w}.${p}`, t, fj);
-      }
-    }
-    if (isObj(m.host)) this.checkSimple(lang, shaderOf);
-  }
-
-  // ui/simple/ui.json and ui/simple/fonts.json of a story with a host
-  checkSimple(lang, shaderOf) {
-    const m = this.man, U = m.host.ui;
-    const ui = this.doc(U, (v) => (isObj(v) && Array.isArray(v.nodes) && v.nodes.every((n) => isObj(n) && typeof n.path === "string") ? [] : ["nodes is not an array of nodes"]));
-    const fj = this.doc("ui/simple/fonts.json", S.storyFonts);
-    if (!ui || !fj) return;
-    this.descriptors(ui, dirOf(U));
-    this.checkFonts("ui/simple/fonts.json", fj, ui, U, dirOf(U), lang, shaderOf);
-  }
-
-  // a text binding's localized font asset and material are in the fonts document; its sprite asset (a text a UIText
-  // drives) is the emoji sprite asset, with m_tintAllSprites
-  binding(F, where, t, fj) {
-    if (!isObj(t) || !isObj(t.localized)) { this.err(F, `${where}: no localized record`); return; }
-    if (!has(fj.fonts, t.localized.fontAsset)) this.err(F, `${where}: font asset ${t.localized.fontAsset} not in fonts`);
-    if (!has(fj.materials, t.localized.material)) this.err(F, `${where}: material ${t.localized.material} not in materials`);
-    this.fallbackMaterials(F, t.localized, fj);
-    if (!has(t, "spriteAsset")) return;
-    if (!has(fj.spriteAssets, t.spriteAsset)) this.err(F, `${where}: sprite asset ${t.spriteAsset} not in spriteAssets`);
-    else if (t.spriteAsset !== fj.emojiSpriteAsset) this.err(F, `${where}: sprite asset ${t.spriteAsset}, emojiSpriteAsset ${fj.emojiSpriteAsset}`);
-    if (!has(t, "m_tintAllSprites")) this.err(F, `${where}: a sprite asset without m_tintAllSprites`);
-  }
-
-  // the fallback materials of a text material M of font asset P (TMP_MaterialManager.GetFallbackMaterial with
-  // TMP_Settings.matchMaterialPreset): per fallback F of P the material "M + F", with M's shader, keywords and values
-  // except F's default material's _MainTex, _GradientScale, _WeightNormal and _WeightBold, and the ratios
-  // UpdateShaderRatios gives for those
   fallbackMaterials(F, loc, fj) {
     const f = fj.fonts[loc.fontAsset], m = fj.materials[loc.material];
     if (!isObj(f) || !isObj(m)) return;
@@ -1551,74 +1405,6 @@ class Story extends Chart {
     }
   }
 
-  // a fonts document F (ui/fonts.json, ui/simple/fonts.json) of the UI document `ui` (path U, texture paths relative
-  // to `dir`): language, source, a binding per text node, materials, glyph pages, font assets
-  checkFonts(F, fj, ui, U, dir, lang, shaderOf) {
-    const m = this.man, group = this.groups[lang].files;
-    if (fj.language !== lang) this.err(F, `language ${fj.language}`);
-    if (fj.source !== m.fonts) this.err(F, `source ${fj.source}, manifest fonts ${m.fonts}`);
-    const textNodes = new Set(ui.nodes.filter((n) => has(n, "textStyle")).map((n) => n.path));
-    for (const p of textNodes) if (!has(fj.texts, p)) this.err(F, `text node ${p} has no binding in texts`);
-    for (const [p, t] of Object.entries(fj.texts)) {
-      if (!textNodes.has(p)) this.err(F, `texts.${p}: not a text node of ${U}`);
-      this.binding(F, `texts.${p}`, t, fj);
-    }
-    for (const n of Object.keys(fj.materialKeywords)) if (!has(fj.materials, n)) this.err(F, `materialKeywords.${n}: not in materials`);
-    shaderOf(F, fj.materials, fj.materialKeywords);
-    // glyph pages: listed in the group (never common: page names differ between languages), PNG as described
-    for (const [n, t] of Object.entries(fj.textures)) {
-      const p = inDir(dir, t.texture);
-      if (!has(group, p)) { this.err(F, `textures.${n}: ${p} not in the language group`); continue; }
-      this.png(p, desc(t), true);
-    }
-    for (const [name, f] of Object.entries(fj.fonts)) {
-      const where = `${F} fonts.${name}`;
-      if (!has(fj.materials, f.material)) this.err(where, `material ${f.material} not in materials`);
-      for (const fb of f.fallbacks) if (!has(fj.fonts, fb)) this.err(where, `fallback ${fb} not in fonts`);
-      if (f.fallbacks.includes(name) || new Set(f.fallbacks).size !== f.fallbacks.length) this.err(where, "fallbacks list the asset itself or an asset twice");
-      let bad = 0;
-      for (const [u, c] of Object.entries(f.characters)) if (!has(f.glyphs, String(c.glyph)) && bad++ < 5) this.err(where, `character ${u}: glyph ${c.glyph} not in glyphs`);
-      this.glyphPages(where, f.glyphs, fj.textures);
-      if (has(f, "missingGlyph")) this.missingGlyph(where, f, fj);
-    }
-    // coverage.missingGlyph: the characters of the font assets' missingGlyph, ascending (absent without any)
-    const substituted = [...new Set(Object.values(fj.fonts).flatMap((f) => (isObj(f.missingGlyph) ? f.missingGlyph.characters : [])))].sort((a, b) => a - b);
-    const covered = has(fj.coverage, "missingGlyph") ? fj.coverage.missingGlyph : [];
-    if (!sameJson(covered, substituted.map((u) => String.fromCodePoint(u))))
-      this.err(F, `coverage.missingGlyph ${JSON.stringify(covered)}, the font assets' missingGlyph characters ${substituted.map(hexU).join(" ") || "none"}`);
-    // sprite assets: emojiSpriteAsset one of them; each with its sprite material, characters in table order and on
-    // glyphs, glyph pages; coverage.sprites with them: the characters held and the sprites without an image
-    const sprites = isObj(fj.spriteAssets) ? fj.spriteAssets : null;
-    if (sprites && !has(sprites, fj.emojiSpriteAsset)) this.err(F, `emojiSpriteAsset ${fj.emojiSpriteAsset} not in spriteAssets`);
-    if (!sprites && has(fj, "emojiSpriteAsset")) this.err(F, "emojiSpriteAsset without spriteAssets");
-    if (!!sprites !== has(fj.coverage, "sprites")) this.err(F, sprites ? "spriteAssets without coverage.sprites" : "coverage.sprites without spriteAssets");
-    for (const [name, sa] of Object.entries(sprites || {})) {
-      const where = `${F} spriteAssets.${name}`;
-      const mat = fj.materials[sa.material];
-      if (!mat) this.err(where, `material ${sa.material} not in materials`);
-      else if (mat.shader.shader !== TMP_SPRITE_SHADER) this.err(where, `material ${sa.material}: shader ${mat.shader.shader}, not ${TMP_SPRITE_SHADER}`);
-      if (sa.characters.some((c, i) => i > 0 && c.index <= sa.characters[i - 1].index)) this.err(where, "characters not in the order of their index");
-      let bad = 0;
-      for (const c of sa.characters) if (!has(sa.glyphs, String(c.glyph)) && bad++ < 5) this.err(where, `character ${c.name}: glyph ${c.glyph} not in glyphs`);
-      this.glyphPages(where, sa.glyphs, fj.textures);
-    }
-    if (sprites && isObj(fj.coverage.sprites)) {
-      const all = Object.values(sprites).flatMap((sa) => sa.characters.map((c) => [c, sa.glyphs[String(c.glyph)]]));
-      const cs = fj.coverage.sprites;
-      if (cs.characters !== all.length) this.err(F, `coverage.sprites.characters ${cs.characters}, the sprite assets hold ${all.length}`);
-      for (const n of cs.missing) {
-        const hit = all.filter(([c]) => c.name === n);
-        if (!hit.length) this.err(F, `coverage.sprites.missing: ${n} is not a sprite character`);
-        else if (hit.some(([, g]) => isObj(g) && has(g, "packed"))) this.err(F, `coverage.sprites.missing: ${n} has an image`);
-      }
-    }
-    // without sprite assets no binding has one (binding() checks the name otherwise)
-    if (!sprites) {
-      const groups = [fj.texts, ...["dialogTexts", "chatTexts", "frameTexts"].flatMap((k) => Object.values(isObj(fj[k]) ? fj[k] : {}))];
-      const hit = groups.flatMap((g) => Object.entries(g)).find(([, t]) => has(t, "spriteAsset"));
-      if (hit) this.err(F, `${hit[0]}: a sprite asset without spriteAssets`);
-    }
-  }
 }
 
 // ------------------------------------------------------------------------------------------------ main
@@ -1690,9 +1476,16 @@ function runAll(site, list, Kind) {
 }
 
 function main(argv) {
-  const [dir, ...only] = argv;
+  const [dir, ...args] = argv, only = [], languages = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--lang") languages.push(...String(args[++i] || "").split(","));
+    else if (args[i].startsWith("--lang=")) languages.push(...args[i].slice(7).split(","));
+    else only.push(args[i]);
+  }
+  if (languages.some((lang) => !Object.hasOwn(STORY_LANGUAGES, lang))) { console.error("--lang: unknown story language"); return 2; }
   if (!dir) { console.error("usage: node scripts/validate-data.mjs <site dir> [live id | chart id | model id | story id ...]"); return 2; }
   const site = new Site(dir);
+  site.storyLanguages = languages.length ? [...new Set(languages)] : null;
   const out = [];
   let entries;
   const indexPath = site.file("charts.json");
@@ -1761,7 +1554,7 @@ function main(argv) {
   if (liveList.length) console.log(`${okLives}/${liveList.length} lives valid`);
   if (entries.length || (!liveList.length && !models.length && !stories.length)) console.log(`${ok}/${entries.length} charts valid`);
   if (models.length) console.log(`${okModels}/${models.length} models valid`);
-  if (stories.length) console.log(`${okStories}/${stories.length} stories valid`);
+  if (stories.length) console.log(`${okStories}/${stories.length} stories valid${site.storyLanguages ? ` (languages: ${site.storyLanguages.join(", ")})` : ""}`);
   return okLives === liveList.length && ok === entries.length && okModels === models.length && okStories === stories.length
     && !out.length ? 0 : 1;
 }
diff --git a/src/engine/anim.js b/src/engine/anim.js
index c851df8..29f3329 100644
--- a/src/engine/anim.js
+++ b/src/engine/anim.js
@@ -75,7 +75,7 @@ export class AnimClip {
     if (!Array.isArray(names) || names.length !== clip.bindings.length)
       throw new AnimError(`clip ${key}: ${names ? names.length : "no"} names for ${clip.bindings.length} bindings`);
     return AnimClip._mecanim(clip, key, clip.bindings.map((b, i) => ({
-      path: names[i].path, cls: b.class, typeID: b.typeID, attribute: names[i].attribute, curves: b.curves || 1,
+      path: names[i].path, cls: b.scriptClass?.split("|").at(-1) || b.class, typeID: b.typeID, attribute: names[i].attribute, curves: b.curves || 1,
       pptr: !!b.pptr })));
   }
 
@@ -87,7 +87,7 @@ export class AnimClip {
     const bindings = [];
     for (const b of named) {
       if (b.pptr) {
-        if (b.typeID !== 212 || b.attribute !== "m_Sprite")
+        if (!((b.typeID === 212 && b.cls === "SpriteRenderer") || (b.typeID === 114 && b.cls === "Image")) || b.attribute !== "m_Sprite")
           throw new AnimError(`clip ${name}: PPtr curve ${b.cls}.${b.attribute} not implemented`);
         bindings.push({ path: b.path, cls: b.cls, typeID: b.typeID, attr: "m_Sprite", pptr: true });
         continue;
diff --git a/src/engine/audio.js b/src/engine/audio.js
index e29f66d..baef278 100644
--- a/src/engine/audio.js
+++ b/src/engine/audio.js
@@ -1,7 +1,7 @@
 // Audio: sound playback with the game's SoundManager semantics over decoded CRI cues
-// (audio/<cueSheet>/<cue>.flac + cues.json), and SoundCategoryVolumes (the CRI category volumes).
+// and SoundCategoryVolumes (the CRI category volumes).
 //
-// A master sound id resolves to {sheet, cue, category, row} through the resolver
+// A master sound id resolves to {sheet, cue, category, row, meta} through the resolver
 // passed to the constructor (LiveSoundManager: the sounds of live-audio.json; a story: Audio.episodeResolver over
 // the episode's -Sound / -SoundCueSheet rows). The row is a MasterSound record ({_category, _soundCueSheetID,
 // _cueName, ...}).
@@ -22,8 +22,20 @@ export const SOUND_CATEGORY = { Bgm: 0, Se: 1, Voice: 2, NotesSe: 3, All: 9999 }
 // buffer (rounded by `round`). At equal rates the count is n itself. Times in seconds (loop points, start offsets, the
 // audio-synced time) do not depend on the rate.
 export const framesAt = (n, from, to, round = Math.round) => (from === to ? n : round(n * to / from));
+export const SOUND_CATEGORY_NAME = { 0: "Bgm", 1: "Se", 2: "Voice" };        // SoundCategory enum names
 export const SOUND_BUS_GAIN = { 0: 0.7, 1: 1.0, 2: 1.0 };
 
+// The bus of a cue. ENGINE: the game never attaches a category to a sound (SoundCache.CreateSoundSource and
+// SoundPlayer.Play call no CriAtomExPlayer.SetCategory), so the CRI category volumes reach a cue through the
+// categories its sheet puts it in (cues.json `categories`: the CRI category names of the cue in the ACB), whatever
+// category its -Sound row names. The row's category decides which sounds StopAll and the BGM crossfade reach
+// (SoundInfo.Category). A cue without categories plays on its row's.
+export const busOf = (meta, category) => {
+  for (const name of (meta && meta.categories) || [])
+    for (const k of Object.keys(SOUND_CATEGORY_NAME)) if (SOUND_CATEGORY_NAME[k] === name) return Number(k);
+  return category;
+};
+
 // Fwk.Sound.SoundVolume over the CRI category volumes. SoundVolumeSettings gives each category name its
 // DefaultVolume; SoundManager.Boot calls ChangeVolume("All", 1.0), so every category starts at DefaultVolume.
 //   ChangeVolume: "All" (SoundCategoryNames.All) -> ChangeVolumeAll (every settings entry);
@@ -37,7 +49,6 @@ export const SOUND_BUS_GAIN = { 0: 0.7, 1: 1.0, 2: 1.0 };
 //   ChangeConfigVolume (the app's volume options): "All" -> every settings name's "<name>Config" = DefaultVolume x v;
 //     any other name -> CriAtomExCategory.SetVolume(name + "Config", v); RestoreConfigVolume = ChangeConfigVolume(1).
 export const SOUND_VOLUME_SETTINGS = { Bgm: 0.7, Se: 1.0, Voice: 1.0, LiveBgm: 1.0, LiveSe: 1.0, LiveNotesSe: 1.0, LiveVoice: 1.0 };
-export const SOUND_CATEGORY_NAME = { 0: "Bgm", 1: "Se", 2: "Voice" };        // SoundCategory enum names
 export class SoundCategoryVolumes {
   constructor(onChange) {
     this.onChange = onChange;               // (name, volume) after a CRI category volume changed
@@ -196,15 +207,15 @@ export class Audio {
   async suspend() { if (this.ctx.state === "running") await this.ctx.suspend(); }
 
   // The resolver of a story episode: sound id -> its -Sound row (episode.sounds) -> the row's -SoundCueSheet row
-  // (episode.cuesheets) -> {sheet: _cueSheetName, cue: _cueName, category: _category, row}; the cue's waveform is
-  // audio/<sheet>/<file of the cue in audio/<sheet>/cues.json>.
-  static episodeResolver(episode) {
+  // (episode.cuesheets), with cue metadata and a product-relative waveform path from StoryData.
+  static episodeResolver(episode, data) {
     return (soundId) => {
       const s = episode.sounds[String(soundId)];
       if (!s) throw new Error(`sound ${soundId} not in the episode's -Sound rows`);
       const sheet = episode.cuesheets[String(s._soundCueSheetID)];
       if (!sheet) throw new Error(`cue sheet ${s._soundCueSheetID} not in the episode's -SoundCueSheet rows`);
-      return { sheet: sheet._cueSheetName, cue: s._cueName, category: s._category, row: s };
+      return { sheet: sheet._cueSheetName, cue: s._cueName, category: s._category, row: s,
+               meta: data.cues(sheet._cueSheetName)[s._cueName] };
     };
   }
 
@@ -218,10 +229,10 @@ export class Audio {
     for (const id of soundIds) {
       const c = this.cueOf(id), key = `${c.sheet}/${c.cue}`;
       if (this.buffers.has(key)) continue;
-      const meta = this.assets.json(`audio/${c.sheet}/cues.json`)[c.cue];
+      const meta = c.meta;
       if (!meta) throw new Error(`cue ${c.cue} not decoded in ${c.sheet}`);
       // decoded at the context's rate; the loop points below are converted to seconds with the cue's own rate
-      const buf = await this.ctx.decodeAudioData(this.assets.arrayBuffer(`audio/${c.sheet}/${meta.file}`));
+      const buf = await this.ctx.decodeAudioData(this.assets.arrayBuffer(meta.file));
       this.buffers.set(key, { buf, meta });
     }
   }
@@ -237,7 +248,7 @@ export class Audio {
       forceFadeIn = true;
       for (const i of [...this.playing.values()]) if (i.category === SOUND_CATEGORY.Bgm) this._stopInfo(i, true, crossFade);
     }
-    const bus = this.buses[c.category];
+    const bus = this.buses[busOf(entry.meta, c.category)];
     if (!bus) throw new Error(`sound category ${c.category}`);
     const info = { id: this.nextId++, soundId, category: c.category, cue: c, meta: entry.meta, buf: entry.buf,
                    fade: 0, fadeStart: 0, fadeDur: 0, finished: false, stopped: false, onFinished: [],
diff --git a/src/live/objects.js b/src/engine/objects.js
similarity index 75%
rename from src/live/objects.js
rename to src/engine/objects.js
index bb1b346..6a804d2 100644
--- a/src/live/objects.js
+++ b/src/engine/objects.js
@@ -1,10 +1,10 @@
 import { refId } from "../data/assets.js";
-import { AnimBindings, AnimClip, AnimController } from "../engine/anim.js";
-import { ShaderLib } from "../engine/glsl.js";
-import { Prefab, scriptClass } from "../engine/prefab.js";
-import { GLTex } from "../engine/texture.js";
+import { AnimBindings, AnimClip, AnimController } from "./anim.js";
+import { ShaderLib } from "./glsl.js";
+import { Prefab, scriptClass } from "./prefab.js";
+import { GLTex } from "./texture.js";
 
-// LiveObjects: the objects of a live's store (docs/data-format.md "Objects") as the live modules read them, each made
+// ObjectResources: the objects of a product store (docs/data-format.md "Objects") as playback modules read them, each made
 // once per session. A value `v` is a reference as an object holds it ({"$ref": ...}) or an object id as a document
 // holds it; null gives null.
 //   material(v)   a Material: material.json with `id`, `shader` = the id of its Shader object (read when a draw
@@ -24,7 +24,7 @@ import { GLTex } from "../engine/texture.js";
 //   shaderInfo(id)  the parsed Shader object
 // With a GL context: `lib`, the ShaderLib over every Shader object of the store (by object id; `shaders` {Unity name:
 // id} answers Shader.Find), and texture(id) -> Promise<GLTex>, the GL texture of a Texture2D object (uploaded once).
-export class LiveObjects {
+export class ObjectResources {
   constructor(assets, { bindings = [], shaders = {}, gl = null } = {}) {
     this.assets = assets;
     this.bindings = new AnimBindings(bindings);
@@ -38,6 +38,7 @@ export class LiveObjects {
     this._events = new Map();         // clip id -> the events every AnimClip of it shares
     this._controllers = new Map();
     this._textures = new Map();
+    this._profiles = new Map();
   }
 
   // the object id of a reference ({"$ref": ...}) or of an object id as a document gives it, checked to be in the store
@@ -91,6 +92,40 @@ export class LiveObjects {
 
   shaderInfo(id) { this.assets.object(id, "Shader"); return this.assets.objectJson(id); }
 
+  profile(v) {
+    const id = this.id(v, "MonoBehaviour");
+    if (id === null) return null;
+    if (!this._profiles.has(id)) {
+      const raw = this.mono(id);
+      this._profiles.set(id, { id, name: raw.m_Name, components: raw.components.map((ref) => {
+        const c = this.mono(ref);
+        return { ...c, asset: c.class };
+      }) });
+    }
+    return this._profiles.get(id);
+  }
+
+  rendererData(graphicsId, rendererIndex) {
+    const graphics = this.assets.objectJson(graphicsId);
+    const pipeline = this.mono(graphics.m_CustomRenderPipeline);
+    const index = rendererIndex < 0 ? pipeline.m_DefaultRendererIndex : rendererIndex;
+    return this.mono(pipeline.m_RendererDataList[index]);
+  }
+
+  grainTextures(graphicsId, rendererIndex) {
+    const renderer = this.rendererData(graphicsId, rendererIndex);
+    return this.mono(renderer.postProcessData).textures.filmGrainTex.map((ref) => this.id(ref, "Texture2D"));
+  }
+
+  uiBlur(graphicsId, rendererIndex) {
+    const renderer = this.rendererData(graphicsId, rendererIndex);
+    const feature = renderer.m_RendererFeatures.map((ref) => this.mono(ref))
+      .find((m) => m.class === "UIRendererFeature");
+    if (!feature) return null;
+    return { enabled: !!feature.m_Active, renderer: rendererIndex, iterations: feature._blurIterations,
+      offset: feature._blurOffset, downsample: feature._blurDownsample, blendRateMax: feature._blurBlendRateMax };
+  }
+
   prefab(id) {
     let p = this._prefabs.get(id);
     if (!p) { p = Prefab.fromObjects(this.assets, [id], id); this._prefabs.set(id, p); }
@@ -126,7 +161,7 @@ export class LiveObjects {
   }
 
   texture(id) {
-    if (!this.gl) throw new Error("LiveObjects: no GL context for textures");
+    if (!this.gl) throw new Error("ObjectResources: no GL context for textures");
     let t = this._textures.get(id);
     if (!t) { t = GLTex.loadObject(this.gl, id, this.assets); this._textures.set(id, t); }
     return t;
diff --git a/src/engine/postfx.js b/src/engine/postfx.js
index bba075c..13031d2 100644
--- a/src/engine/postfx.js
+++ b/src/engine/postfx.js
@@ -1,3 +1,4 @@
+import { refId } from "../data/assets.js";
 import { F } from "./core.js";
 import { applyState } from "./glsl.js";
 import { mat4 } from "./math.js";
@@ -198,25 +199,28 @@ export class URPPost {
 
   // the textures the overridden texture parameters of `profiles` name (FilmGrain.texture of a Custom grain), by exported
   // file; the Uber shader samples the grain with its inline sampler_LinearRepeat (other textures: bilinear, clamp)
-  async loadVolumeTextures(base, profiles, assets) {
+  async loadVolumeTextures(profiles, objects) {
     const gl = this.gl;
     for (const p of profiles) {
       for (const comp of (p && p.components) || []) {
         for (const [k, v] of Object.entries(comp)) {
           const d = v && typeof v === "object" && v.m_OverrideState ? v.m_Value : null;
-          if (!d || typeof d !== "object" || typeof d.texture !== "string" || this.volumeTextures.has(d.texture)) continue;
-          const t = await GLTex.load(gl, base, d, assets);
+          if (!d?.$ref) continue;
+          const id = objects.id(d, "Texture2D");
+          if (!id || this.volumeTextures.has(id)) continue;
+          const t = await objects.texture(id);
           const repeat = comp.asset === "FilmGrain" && k === "texture";
+          gl.bindTexture(gl.TEXTURE_2D, t.glTexture);
           GLTex.sampler(gl, { m_FilterMode: 1, m_WrapU: repeat ? 0 : 1, m_WrapV: repeat ? 0 : 1 }, 1);
-          this.volumeTextures.set(d.texture, t);
+          this.volumeTextures.set(id, t);
         }
       }
     }
   }
 
   _volumeTexture(desc) {
-    const t = this.volumeTextures.get(desc.texture);
-    if (!t) throw new Error(`volume texture ${desc.name || desc.texture} not loaded (URPPost.loadVolumeTextures)`);
+    const t = this.volumeTextures.get(refId(desc));
+    if (!t) throw new Error(`volume texture ${refId(desc)} not loaded (URPPost.loadVolumeTextures)`);
     return t;
   }
 
diff --git a/src/engine/prefab.js b/src/engine/prefab.js
index f9776ce..541ed6c 100644
--- a/src/engine/prefab.js
+++ b/src/engine/prefab.js
@@ -37,9 +37,44 @@ export class Prefab {
   static fromObjects(assets, ids, key = ids.join(" ")) {
     const p = new Prefab({ key, nodes: ids.flatMap((id) => assets.prefab(id).nodes) });
     p.ids = ids.slice();
+    p.references = new Map();
+    for (const id of ids) {
+      const file = id.slice(0, id.lastIndexOf(":"));
+      for (const n of assets.prefab(id).nodes) {
+        if (n.pathId !== undefined) p.references.set(`${file}:${n.pathId}`, { path: n.path, component: null });
+        if (n.transformPathId !== undefined) p.references.set(`${file}:${n.transformPathId}`, { path: n.path, component: null });
+        for (const c of n.components) p.references.set(`${file}:${c.pathId}`, { path: n.path, component: c });
+      }
+    }
     return p;
   }
 
+  // Resolve local hierarchy paths and serialized object references without changing component fields.
+  pathOf(ref) {
+    if (!ref) return null;
+    if (ref.$ref) {
+      const id = `${ref.$ref.file}:${ref.$ref.pathId}`, hit = this.references?.get(id);
+      if (!hit) throw new Error(`${this.key}: reference ${id} is outside the hierarchy`);
+      return hit.path;
+    }
+    const path = ref.transform ?? ref.gameObject;
+    if (typeof path !== "string" || !this.nodes.has(path)) throw new Error(`${this.key}: invalid hierarchy reference`);
+    return path;
+  }
+
+  transformOf(ref) { const path = this.pathOf(ref); return path === null ? null : this.transform(path); }
+
+  componentOf(ref, cls = null) {
+    if (!ref) return null;
+    if (ref.$ref) {
+      const id = `${ref.$ref.file}:${ref.$ref.pathId}`, hit = this.references?.get(id);
+      if (!hit?.component) throw new Error(`${this.key}: reference ${id} is not a component`);
+      if (cls && componentClass(hit.component) !== cls) throw new Error(`${id}: expected ${cls}`);
+      return hit.component;
+    }
+    return this.component(this.pathOf(ref), cls || ref.class || ref.component);
+  }
+
   // the `fields` of the unique component of class `cls` on `path` (prefab.json)
   fields(path, cls) { return this.component(path, cls).fields; }
 
diff --git a/src/engine/ugui.js b/src/engine/ugui.js
index e31a0e8..807a22a 100644
--- a/src/engine/ugui.js
+++ b/src/engine/ugui.js
@@ -2,6 +2,7 @@ import { F } from "./core.js";
 import { applyState } from "./glsl.js";
 import { AnimClip, Animator } from "./anim.js";
 import { easeF } from "./tween.js";
+import { componentClass } from "./prefab.js";
 
 // uGUI subset on WebGL2 with the game's UI shaders, for the live UI canvases (judgement text, combo counter,
 // canvas.js) and the story's front canvas: RectTransform layout, Image simple / sliced meshes, sprites, CanvasGroup,
@@ -75,6 +76,27 @@ export class UIClip extends AnimClip {
 // empty "Idle" clips (AdvLocation / AdvTitle); such a state writes nothing.
 // ENGINE: what an empty state writes with Write Defaults is native; the states here write nothing (Write Defaults off).
 export class UIAnimator extends Animator {
+  static fromObjects(node, objects, controller, prefab, path) {
+    const ctrl = objects.controller(controller, prefab, path);
+    const animator = new Animator(ctrl, (b) => {
+      const target = b.path ? node.find(b.path) : node;
+      const attr = b.attr.replace("localEulerAnglesRaw", "localEulerAngles");
+      const set = UI_CLIP_TARGET[`${b.cls}.${attr}`];
+      if (!set) throw new UIError(`${node.path}: animation property ${b.cls}.${b.attr} not implemented`);
+      const get = () => {
+        if (b.cls === "CanvasGroup") return target.canvasGroup.alpha;
+        const [field, axis] = attr.split(".");
+        if (field === "localEulerAngles") return target.euler?.[axis] ?? (axis === "z" ? target.rotationZ : 0);
+        const key = field.replace(/^m_/, "");
+        return target[key[0].toLowerCase() + key.slice(1)][axis];
+      };
+      return { get, set: (v) => set(target, v) };
+    });
+    Object.setPrototypeOf(animator, UIAnimator.prototype);
+    animator.node = node;
+    return animator;
+  }
+
   constructor(node, ctrl, clips) {
     const states = ctrl.states.map((s) => {
       const key = `${ctrl.name}/${s.clip}`;
@@ -125,13 +147,18 @@ export class UINode {
     this.rotationZ = 2 * Math.atan2(q.z, q.w) * 180 / Math.PI;
     this.euler = null;                  // set by an Animator (Transform.localEulerAngles)
     this.localScale = { x: rec.localScale.x, y: rec.localScale.y };
-    this.canvasGroup = rec.canvasGroup && rec.canvasGroup.m_Enabled
-      ? { alpha: rec.canvasGroup.m_Alpha, ignoreParentGroups: !!rec.canvasGroup.m_IgnoreParentGroups } : null;
+    const group = rec.components?.find((c) => componentClass(c) === "CanvasGroup")?.fields || rec.canvasGroup;
+    this.canvasGroup = group && group.m_Enabled
+      ? { alpha: group.m_Alpha, ignoreParentGroups: !!group.m_IgnoreParentGroups } : null;
     this.rec = rec;
+    this.ignoreLayout = !!(this.fields("LayoutElement")?.m_IgnoreLayout || rec.layoutElement?.m_IgnoreLayout);
     this.rect = null;                   // {x, y, w, h} in own local space (after layout)
     this.matrix = null;                 // local -> canvas space
   }
 
+  component(cls) { return this.rec.components?.find((c) => componentClass(c) === cls) || null; }
+  fields(cls) { return this.component(cls)?.fields || null; }
+
   setEuler(axis, v) {
     if (!this.euler) this.euler = { x: 0, y: 0, z: this.rotationZ };
     this.euler[axis] = v;
diff --git a/src/live/background.js b/src/live/background.js
index 1c16034..cc9f458 100644
--- a/src/live/background.js
+++ b/src/live/background.js
@@ -23,7 +23,7 @@ export const LiveLightWeightBackground = {
   ROOT: "Live/RenderCanvas/LightWeightCompositeRoot",
   LAYERS: ["Layer_JacketLarge", "Layer_BaseWhite", "Layer_JacketSmall", "Layer_StageBg"],   // CreateCompositedRenderTexture array order
 
-  // normalised layer rects in the root (pure); objects: LiveObjects, sprites: {stage, jacket} (the band's LightWeight
+  // normalised layer rects in the root (pure); objects: ObjectResources, sprites: {stage, jacket} (the band's LightWeight
   // background sprite, the music's jacket sprite: object ids)
   layers(objects, prefab, sprites) {
     const root = prefab.nodes.get(LiveLightWeightBackground.ROOT).node;
diff --git a/src/live/fx-effects.js b/src/live/fx-effects.js
index 86c556f..e6234db 100644
--- a/src/live/fx-effects.js
+++ b/src/live/fx-effects.js
@@ -22,7 +22,7 @@ import { FxParticleSystem, PS_STOP } from "../engine/particles.js";
 //     UpdateFrame; LiveGameLaneEffectBase.Initialize / SetWidth / Play /
 //     Stop / IsPlaying; Live{Renderer,Particle}OrderInLayerSetter.Awake,
 //     LiveOrderInLayerUtility.GetOrderInLayer.
-//   - Data: the live's objects (LiveObjects): the effect set's LiveNoteEffectAssetSettings (noteeffect.json
+//   - Data: the live's objects (ObjectResources): the effect set's LiveNoteEffectAssetSettings (noteeffect.json
 //     settings) and the lane effects' LiveLaneEffectAssetSettings (notes.json laneEffect), each field a reference to
 //     the LiveNoteEffectAsset / LiveLaneEffectAsset of an effect prefab; the prefabs' prefab.json, controllers and
 //     clips (bindings named by the documents' bindings tables); the score; constants of the scene [EmbScene/Live]
@@ -286,7 +286,7 @@ export class FxSpriteRenderer {
 // One instance of an effect prefab (a root GameObject's prefab.json) inside its pool element: the element
 // GameObject (clone of the scene placeholder container_root/prefabs/<name>, identity, the LiveGameNoteEffectBase /
 // LiveGameLaneEffectBase host) -> placeholder child `root` (identity, _prefabAssetRoot) -> the prefab root.
-//   Components: Animator (its controller and clips through LiveObjects, shared between instances like Unity's
+//   Components: Animator (its controller and clips through ObjectResources, shared between instances like Unity's
 //   assets), SpriteRenderers (FxSpriteRenderer), ParticleSystems (FxParticleSystem, children filled in
 //   hierarchy order), Live{Renderer,Particle}OrderInLayerSetter, LiveNoteEffectAsset / LiveLaneEffectAsset (width
 //   fitting, Play / Stop), AnimationFinishEventTrigger (event at clip.length -> onStop).
@@ -296,7 +296,7 @@ export class FxSpriteRenderer {
 // ENGINE: activation is native; OnEnable / OnDisable run immediately inside SetActive and m_IsActive writes, parent first.
 // The order among siblings has no visible effect here.
 export class FxPrefab {
-  // id: the prefab's root GameObject; opts {objects (LiveObjects), materials (FxMaterials | null), rng (UnityRandom),
+  // id: the prefab's root GameObject; opts {objects (ObjectResources), materials (FxMaterials | null), rng (UnityRandom),
   // parent (Transform of the pool container), name}
   constructor(id, { objects, materials = null, rng = null, parent = null, name = "" } = {}) {
     const pf = Prefab.fromObjects(objects.assets, [id], id);           // a hierarchy of its own per instance
@@ -434,7 +434,7 @@ export class FxPrefab {
   }
 
   // ----------------------------------------------------------------------------------------- Animator
-  // The controller's clips are named for this Animator's node (LiveObjects.controller); `clipList` is
+  // The controller's clips are named for this Animator's node (ObjectResources.controller); `clipList` is
   // runtimeAnimatorController.animationClips, `rawName` the AnimationClip.name AnimationFinishEventTrigger matches.
   _buildAnimator(comp) {
     if (comp.m_KeepAnimatorStateOnDisable || comp.m_WriteDefaultValuesOnDisable || comp.m_UpdateMode !== 0 || comp.m_ApplyRootMotion)
@@ -769,7 +769,7 @@ export const FxContainerChain = (names) => {
 // LiveAllNoteEffectView (LiveGameView/root/LiveGameNoteEffectView): one-shot note effects per judged note and the
 // slide hold loop per held long line. Effects are drawn by LiveEffectCamera (layer 29): camera "effect".
 export class LiveNoteEffects {
-  // opts {objects (LiveObjects), effect (noteeffect.json of the effect set: MasterLiveNoteEffectSkin of NoteEffectId,
+  // opts {objects (ObjectResources), effect (noteeffect.json of the effect set: MasterLiveNoteEffectSkin of NoteEffectId,
   //       its Light set at LiveQuality Low; SoloLiveResourceLoadStateNode.CreateLoadParameter), score
   //       (score/<file>.notes.json), materials (FxMaterials), rng (UnityRandom), sceneInfo (FxScene.read),
   //       judgementRoot3D (localToWorld of judgement_root; default = sceneInfo)}
diff --git a/src/live/fx-ui.js b/src/live/fx-ui.js
index ffd5519..559f7f4 100644
--- a/src/live/fx-ui.js
+++ b/src/live/fx-ui.js
@@ -19,7 +19,7 @@ import { DOTRunner, DOTSequence, UIAffine, UIDraw, UIError, UIImage, UILayout, U
 //   LiveCanvasOrderInLayerSetter.Awake + LiveOrderInLayerUtility.GetOrderInLayer (100 -> 10000);
 //   DOTween: the DOTween model in engine/ugui.js (Punch, SetPunch, Vector3ArrayPlugin and the Sequence cycle follow
 //   the game's DOTween build; the rest follows DOTween's documented behaviour).
-// Data: the scene product through LiveObjects: scene.json `scene` (the nodes under Live/LiveUICanvas),
+// Data: the scene product through ObjectResources: scene.json `scene` (the nodes under Live/LiveUICanvas),
 // prefabs.judgeEffectView (UILiveNoteJudgeEffectView), spriteAssets.judgement / combo (LiveJudgementSpriteAsset,
 // LiveComboSpriteAsset), the UILiveCombo Animator's controller and clips (bindings named for that Animator), the sprites
 // and textures they reference, and UI/Default from the shader name table.
@@ -50,7 +50,7 @@ export const liveComp = (rec, cls) => {
 // The fields UINode reads (path, name, active, rect, localRotation, localScale, canvasGroup) plus the components
 // this module uses; graphics other than Image / TextMeshProUGUI do not occur in the subset (checked).
 export class LiveUITree {
-  // objects: LiveObjects (the sprites and their textures)
+  // objects: ObjectResources (the sprites and their textures)
   constructor(refPPU, objects) {
     this.refPPU = refPPU;
     this.objects = objects;
@@ -329,7 +329,7 @@ export class LiveUIFx {
   // (Only matters if Init / Add arrive inside a running Init fade, which auto play at Perfect never does.)
   // settings: the live settings (settings.js) read by LiveUIView.Initialize (ComboCountDisplay 206,
   // ContinuationEffectDisplay 208, JudgeResultPositionType 103); absent: the defaults.
-  // objects: LiveObjects; scene: scene.json
+  // objects: ObjectResources; scene: scene.json
   constructor(gl, { objects, scene, settings = null }, opts = {}) {
     this.gl = gl;
     this.objects = objects;
diff --git a/src/live/fx.js b/src/live/fx.js
index 8ab0934..34d7a5d 100644
--- a/src/live/fx.js
+++ b/src/live/fx.js
@@ -24,7 +24,7 @@ import { LiveIntroStars } from "./particles.js";
 // (The sync is PostLateUpdate ParticleSystemEndUpdateAll, so stepping in the animation phase is equivalent for drawing.)
 
 export class LiveFx {
-  // gl may be null (Node tests). objects = the live's LiveObjects; scene, notes, effect = scene.json, notes.json and
+  // gl may be null (Node tests). objects = the live's ObjectResources; scene, notes, effect = scene.json, notes.json and
   // the selected effect set's noteeffect.json; score = score/<file>.notes.json. introStars = () => stage.intro.stars()
   // (the 7 lane-in star emitters of the start timeline; the session constructs LiveFx after the stage so that this
   // object's animation hook runs after the timeline evaluation of the frame, as Unity's DirectorUpdateAnimation precedes
diff --git a/src/live/intro.js b/src/live/intro.js
index 30bc235..e6cf078 100644
--- a/src/live/intro.js
+++ b/src/live/intro.js
@@ -344,7 +344,7 @@ export class LiveLaneInEffect {
 // root bone; the same world positions).
 // ENGINE: the mesh has no colour channel; the missing COLOR input is taken as (1, 1, 1, 1).
 export class LiveSkinnedMesh {
-  // smr: the SkinnedMeshRenderer's fields; objects: LiveObjects (its mesh and material)
+  // smr: the SkinnedMeshRenderer's fields; objects: ObjectResources (its mesh and material)
   constructor(prefab, path, smr, layer, objects) {
     this.pf = prefab; this.path = path; this.smr = smr; this.layer = layer;
     const m = objects.mesh(smr.m_Mesh);
diff --git a/src/live/lane.js b/src/live/lane.js
index 2bc23dd..66a4e07 100644
--- a/src/live/lane.js
+++ b/src/live/lane.js
@@ -105,7 +105,7 @@ export const LiveLaneLayout = {
   },
 
   // the lane skin's sprites (scene.json laneSkins[settings.laneSkin]: lane_base, lane_tap_area, out_side_line) as
-  // LiveObjects sprites
+  // ObjectResources sprites
   skin(objects, scene) {
     const ids = scene.laneSkins[scene.settings.laneSkin];
     if (!ids) throw new Error(`lane skin ${scene.settings.laneSkin} missing`);
@@ -371,7 +371,7 @@ export const LIVE_UI_DEAD_INPUTS = { _ClipRect: [-32767, -32767, 32767, 32767],
 LiveLane.QUEUE = { Background: 1000, Geometry: 2000, AlphaTest: 2450, Transparent: 3000, Overlay: 4000 };
 
 // Material.renderQueue: the material's custom queue (m_CustomRenderQueue >= 0), else the shader's "Queue" tag
-// ("Transparent", "Geometry+1", ...) of subshader 0. `mat`: a LiveObjects material.
+// ("Transparent", "Geometry+1", ...) of subshader 0. `mat`: a ObjectResources material.
 LiveLane.queue = (lib, mat) => {
   if (mat.renderQueue >= 0) return mat.renderQueue;
   const tags = lib.info(mat.shader).subShaders[0].tags;
diff --git a/src/live/legacy.js b/src/live/legacy.js
index 7058756..b8cb021 100644
--- a/src/live/legacy.js
+++ b/src/live/legacy.js
@@ -6,7 +6,7 @@ import { LIVE_JSON_FORMAT, MUSIC_FORMAT, NOTEEFFECT_FORMAT, NOTES_FORMAT, NOTESK
 // `schema` whose files are a live.json index, the score, audio/live-audio.json with its waveforms, livescene/ and
 // livenotes/. legacyLive() reads such a store as the store of a live: the documents of the live, scene, notes, note
 // skin, note effect, sounds and music products, and the objects they name, so ChartSession reads both through
-// LiveData and LiveObjects.
+// LiveData and ObjectResources.
 //
 // The chart's scene.json and notes.json hold their objects inline: prefabs as node lists, materials, sprites, meshes,
 // MonoBehaviour assets and clips where they are used, textures as file descriptors, clips and controllers of the note
diff --git a/src/live/noteview.js b/src/live/noteview.js
index 4866568..d21b229 100644
--- a/src/live/noteview.js
+++ b/src/live/noteview.js
@@ -57,7 +57,7 @@ export const SpriteMesh = {
 
 // ------------------------------------------------------------------ GL drawing of note renderers
 export class NoteGL {
-  // objects: LiveObjects (its ShaderLib and GL textures)
+  // objects: ObjectResources (its ShaderLib and GL textures)
   constructor(gl, objects) {
     this.gl = gl;
     this.objects = objects;
@@ -109,7 +109,7 @@ export class NoteGL {
     return [mat.floats, mat.colors, texST, this.lib.defaults(shader, this.defTex)];
   }
 
-  // one SpriteRenderer: sr = {m_Materials (LiveObjects materials), m_FlipX, m_FlipY, m_Color}, sprite + mesh, world
+  // one SpriteRenderer: sr = {m_Materials (ObjectResources materials), m_FlipX, m_FlipY, m_Color}, sprite + mesh, world
   // matrix M; mpb: the renderer's MaterialPropertyBlock values (over the material's), or null
   drawSprite(ctx, sr, tex, mesh, M, color, mpb = null) {
     const gl = this.gl, mat = sr.m_Materials[0], shader = mat.shader;
@@ -211,7 +211,7 @@ export const NoteViewType = {
 
 // ------------------------------------------------------------------ one prefab instance (transforms + renderers)
 // prefab: a prefab.json; a node's `comp` is the fields of its SpriteRenderer / MeshRenderer and `materials` that
-// renderer's materials (LiveObjects materials)
+// renderer's materials (ObjectResources materials)
 export class NotePrefab {
   constructor(prefab, skipPrefix, objects) {
     this.root = null;
@@ -542,7 +542,7 @@ export class LiveBarLines {
 
 // ------------------------------------------------------------------ LiveAllNoteView (container of all views)
 export class LiveNotes {
-  // objects = the live's LiveObjects, ln = notes.json, score = score/<chart>.notes.json, opts.skin = the note skin's
+  // objects = the live's ObjectResources, ln = notes.json, score = score/<chart>.notes.json, opts.skin = the note skin's
   // noteskin.json (NoteDesignId), opts.settings = the live settings (settings.js; absent: the data's option defaults),
   // opts.displayOffsetMs = the executor's display offset, opts.scene = the live scene's Prefab and opts.barLineView =
   // the bar line view prefab (scene.json prefabs.barLineView), for the bar lines
diff --git a/src/live/renderer.js b/src/live/renderer.js
index 989c99b..2f52c32 100644
--- a/src/live/renderer.js
+++ b/src/live/renderer.js
@@ -197,7 +197,7 @@ LiveCameraMath.sortItems = (items, opaqueDrawn = true) => {
 };
 
 // ------------------------------------------------------------------------------------------------ renderer
-// `objects` = LiveObjects of the live (its `lib` draws), `scene` = scene.json of the live.scene part (the scene roots,
+// `objects` = ObjectResources of the live (its `lib` draws), `scene` = scene.json of the live.scene part (the scene roots,
 // settings, graphics objects), `loop` = PlayerLoop. The scene's root prefabs make one hierarchy (`prefab`).
 // Screen size: resize(W, H) (Screen.width / height; LiveGameView.FullInitialize runs again on a size change).
 // `settings`: the live settings (settings.js) read by the lane and the render canvas; absent: the data's defaults.
@@ -240,11 +240,7 @@ export class LiveRenderer {
   // The profile's components are VolumeComponent assets (URPPost.evaluateStack reads them by class, `asset`).
   _effectStack() {
     const vol = this.prefab.fields("LiveGameView/LiveGameCamera/LiveEffectCamera", "Volume");
-    const shared = this.objects.mono(vol.sharedProfile);
-    const profile = { components: shared.components.map((v) => {
-      const c = JSON.parse(JSON.stringify(this.objects.mono(v)));
-      return { ...c, asset: c.class };
-    }) };
+    const profile = structuredClone(this.objects.profile(vol.sharedProfile));
     if (this.quality !== LIVE_QUALITY.High)
       for (const c of profile.components)
         if (c.asset === "Bloom") c.maxIterations = { m_OverrideState: 1, m_Value: Math.max(4, c.maxIterations.m_Value - 1) };
@@ -255,12 +251,7 @@ export class LiveRenderer {
   // -> m_RendererDataList[UniversalAdditionalCameraData.m_RendererIndex, -1: m_DefaultRendererIndex] -> its
   // postProcessData (SiriusPostProcessData) -> textures.filmGrainTex (Texture2D ids).
   grainTextures() {
-    const O = this.objects, graphics = O.assets.objectJson(this.scene.graphics.graphics);
-    const pipeline = O.mono(graphics.m_CustomRenderPipeline);
-    const index = this.cameras.effect.uacd.m_RendererIndex;
-    const renderer = O.mono(pipeline.m_RendererDataList[index >= 0 ? index : pipeline.m_DefaultRendererIndex]);
-    const post = O.mono(renderer.postProcessData);
-    return post.textures.filmGrainTex.map((v) => O.id(v, "Texture2D"));
+    return this.objects.grainTextures(this.scene.graphics.graphics, this.cameras.effect.uacd.m_RendererIndex);
   }
 
   async load() {
@@ -401,7 +392,7 @@ export const liveFitSheets = (prog, sheets) => {
 
 // material property sheet [floats with every scalar shader default filled in, colours as arrays] for render state
 // lookups (passState reads state properties such as _ColorMask / _Stencil* from the material floats); `mat`: a
-// LiveObjects material (or a material of the same form whose `shader` is a key of `lib`)
+// ObjectResources material (or a material of the same form whose `shader` is a key of `lib`)
 export const liveMaterialSheets = (lib, mat, tex) => {
   const shader = mat.shader, defaults = lib.defaults(shader, tex), floats = {}, colors = {};
   for (const [k, v] of Object.entries(defaults)) if (typeof v === "number") floats[k] = v;
diff --git a/src/live/session.js b/src/live/session.js
index 0d60580..2e73979 100644
--- a/src/live/session.js
+++ b/src/live/session.js
@@ -8,7 +8,7 @@ import { LiveData } from "./data.js";
 import { LiveFx } from "./fx.js";
 import { isLegacyLive, legacyLive } from "./legacy.js";
 import { LiveNotes } from "./noteview.js";
-import { LiveObjects } from "./objects.js";
+import { ObjectResources } from "../engine/objects.js";
 import { LiveRenderer } from "./renderer.js";
 import { LIVE_OPTION_BY_NAME, LiveOptionContext, LiveSettingsError, liveCategoryVolumes, liveDerived, liveNoteEffectName,
          liveNoteSeMaps, liveOptionItems, liveSettingsChanges } from "./settings.js";
@@ -133,7 +133,7 @@ export class ChartSession {
     const effect = data.noteeffect(liveNoteEffectName(ctx, s) ?? undefined);
     // the live's objects: clip bindings of the scene, the notes and the selected skin and effect set; Shader.Find
     // names of the scene
-    const objects = this.objects = new LiveObjects(assets, { gl, shaders: scene.shaders,
+    const objects = this.objects = new ObjectResources(assets, { gl, shaders: scene.shaders,
       bindings: [scene.bindings, notes.bindings, skin.bindings, effect.bindings] });
     const loop = new PlayerLoop(60);
     this.loop = loop;
diff --git a/src/story/assets.js b/src/story/assets.js
index ab48c6a..c2548c5 100644
--- a/src/story/assets.js
+++ b/src/story/assets.js
@@ -1,14 +1,9 @@
-import { AssetStore, PRODUCT_MANIFEST, decodeAsset } from "../data/assets.js";
+import { PRODUCT_MANIFEST } from "../data/assets.js";
 import { MODEL_PRODUCT } from "../live2d/model.js";
-import { ADV_PLAYBACK_MODE, StoryCommandError } from "./interfaces.js";
-import { StoryPlayerCore } from "./player-core.js";
-import { simpleUnsupportedCommands } from "./simple/validator.js";
+import { fetchStoryProduct, loadStoryProducts } from "./store.js";
 
-// Loading a story from a site: the story manifest (stories/<advId>.json, stories/<region>/<advId>.json), the files of
-// one language and the manifests of the Live2D models it uses (models/<id>.json, products of live2d.model).
-
-// the story manifest format, the formats this player reads
-export const STORY_MANIFEST_FORMAT = "ournotes.story-manifest/2";
+// Story products and their selected language, media and model dependencies share one object store.
+export const STORY_MANIFEST_FORMAT = PRODUCT_MANIFEST;
 export const STORY_MANIFEST_FORMATS = Object.freeze([STORY_MANIFEST_FORMAT]);
 export { MODEL_PRODUCT };
 
@@ -22,75 +17,9 @@ export const checkModelManifest = (mm, id, where) => {
   if (name !== id) throw new Error(`${where}: model ${name}, the story names it ${id}`);
 };
 
-const here = () => (globalThis.document ? globalThis.document.baseURI : globalThis.location ? globalThis.location.href : undefined);
 
-const checkFormat = (man, href) => {
-  if (!man || !STORY_MANIFEST_FORMATS.includes(man.format))
-    throw new Error(`${href}: not a story manifest (${STORY_MANIFEST_FORMATS.join(" or ")})`);
-};
+export const fetchStoryManifest = fetchStoryProduct;
 
-// Fetches a story manifest. Refuses (StoryCommandError) a story whose commands this player lacks, before any other
-// file is fetched: an Overlay episode (playbackMode 1) against the simple player's set (simple/validator.js), any
-// other against the command registry.
-export const fetchStoryManifest = async (url, { fetch = globalThis.fetch, signal = null } = {}) => {
-  if (!url) throw new Error("no story manifest URL");
-  if (typeof fetch !== "function") throw new Error("no fetch function");
-  const href = new URL(String(url), here()).href;
-  const r = await fetch(href, signal ? { signal } : undefined);
-  if (!r.ok) throw new Error(`${href}: HTTP ${r.status}`);
-  const man = await r.json();
-  checkFormat(man, href);
-  const commands = (man.requires && man.requires.commands) || [];
-  const overlay = !!man.story && man.story.playbackMode === ADV_PLAYBACK_MODE.Overlay;
-  const missing = overlay ? simpleUnsupportedCommands(commands)
-    : commands.filter((c) => !StoryPlayerCore.supportedCommands().includes(c));
-  if (missing.length)
-    throw new StoryCommandError(`story ${man.advId}: commands not supported by this player: ${missing.join(", ")}`);
-  return { url: href, manifest: man };
-};
-
-// The AssetStore of one language of a story: the manifest's common files and the language group's files; under
-// live2d/<id>/ the files of every model the manifest lists (their manifests fetched in parallel), and the objects of
-// those models (an object several models use is one object of the store). `lang` defaults to the manifest's
-// language. The store's `info` is the manifest without its file lists, plus `loadedLanguage`.
-// `base`: the site root the asset and model manifest paths are relative to (default: the manifest's `root`, relative
-// to the manifest). `decode`, `concurrency`: as AssetStore.fromManifest.
-export const loadStoryStore = async (url, { lang = null, fetch = globalThis.fetch, signal = null, onProgress = null,
-                                            manifest = null, base = null, decode = decodeAsset, concurrency } = {}) => {
-  const m = manifest || await fetchStoryManifest(url, { fetch, signal });
-  const man = m.manifest, language = lang || man.language;
-  checkFormat(man, m.url);
-  if (typeof man.root !== "string" || !man.models || typeof man.models !== "object")
-    throw new Error(`${m.url}: a story manifest without root / models`);
-  if (!man.languages || !man.languages[language])
-    throw new Error(`story ${man.advId}: no language ${language} (${Object.keys(man.languages || {}).join(", ")})`);
-  const root = base ? new URL(String(base), here()) : new URL(man.root, m.url);
-  const files = { ...man.files, ...man.languages[language].files };
-  const models = await Promise.all(Object.entries(man.models).map(async ([id, p]) => {
-    const u = new URL(p, root).href;
-    if (signal) signal.throwIfAborted();
-    const r = await fetch(u, signal ? { signal } : undefined);
-    if (!r.ok) throw new Error(`${u}: HTTP ${r.status}`);
-    const mm = await r.json();
-    checkModelManifest(mm, id, u);
-    return [id, mm];
-  }));
-  for (const p of Object.keys(files))
-    if (p.startsWith("live2d/")) throw new Error(`story ${man.advId}: ${p}: live2d/ holds the models' files`);
-  const objects = {};
-  for (const [id, mm] of models) {
-    for (const [p, f] of Object.entries(mm.files)) files[`live2d/${id}/${p}`] = f;
-    for (const [oid, o] of Object.entries(mm.objects)) {
-      if (oid in objects && JSON.stringify(objects[oid]) !== JSON.stringify(o))
-        throw new Error(`story ${man.advId}: object ${oid} differs between the manifests of its models`);
-      objects[oid] = o;
-    }
-  }
-  const merged = { ...man, loadedLanguage: language, files, objects };
-  delete merged.languages;
-  merged.languages = Object.fromEntries(Object.keys(man.languages).map((k) => [k, {}]));   // the codes only
-  const inner = (u, init) => (String(u) === m.url
-    ? Promise.resolve(new Response(JSON.stringify(merged), { headers: { "content-type": "application/json" } }))
-    : fetch(u, init));
-  return AssetStore.fromManifest(m.url, { fetch: inner, signal, onProgress, base: root.href, decode, concurrency });
-};
+// A fetched index can be reused across language switches through the public `manifest` option.
+export const loadStoryStore = (url, { manifest = null, ...options } = {}) =>
+  loadStoryProducts(url, { ...options, head: manifest });
diff --git a/src/story/commands/talk.js b/src/story/commands/talk.js
index 6c73638..9c25182 100644
--- a/src/story/commands/talk.js
+++ b/src/story/commands/talk.js
@@ -73,8 +73,8 @@ const lipsAnalyzerFor = (p, info, src) => {
   const ctx = p.ctx;
   let data = lipsData.get(ctx);
   if (data === undefined) {
-    const d = ctx.story && ctx.story.crilips;
-    data = d ? new CriLipsData(ctx.assets.json(d.descriptor), ctx.assets.arrayBuffer(d.data)) : null;
+    const d = ctx.data?.crilips;
+    data = d ? new CriLipsData(d.descriptor, d.data) : null;
     lipsData.set(ctx, data);
   }
   if (!data) return src;
@@ -292,4 +292,3 @@ export const Location = (c, p) => {
     await p.noWait(c, p.ctx.ui.showLocation(name));
   })();
 };
-
diff --git a/src/story/controls.js b/src/story/controls.js
index 0808f49..380a6a0 100644
--- a/src/story/controls.js
+++ b/src/story/controls.js
@@ -238,6 +238,7 @@ export class StoryControls {
     const p = this.player, t = this.t;
     if (p.session !== this._session) { this._session = p.session; if (!this.confirm.hidden) this._pauseForConfirm(); }
     this.btnPlay.textContent = p.paused ? t.play : t.pause;
+    for (const [cat, r] of Object.entries(this.vols)) r.value = String(p._volumes?.[cat] ?? 1);
     this.btnAuto.setAttribute("aria-pressed", String(!!p.auto));
     this.btnSpeed.textContent = `${t.speed} ${speedLabel(p.speed)}`;
     this.btnSpeed.setAttribute("aria-pressed", String(p.speed !== 10));
diff --git a/src/story/data.js b/src/story/data.js
new file mode 100644
index 0000000..36ce8d0
--- /dev/null
+++ b/src/story/data.js
@@ -0,0 +1,92 @@
+import { productDir } from "../data/products.js";
+import { STORY_PRODUCT } from "./store.js";
+
+const FORMATS = { scene: 1, ui: 1, fonts: "nnnotes.story-fonts/1", simpleui: "nnnotes.story-simple-ui/1",
+  host: "nnnotes.story-host/1" };
+
+export class StoryData {
+  constructor(assets) {
+    if (assets?.info?.product !== STORY_PRODUCT || !assets.info.dir || !assets.info.products)
+      throw new Error("not the store of a story product (loadStoryProducts)");
+    this.assets = assets;
+    this.dir = assets.info.dir;
+    this.products = assets.info.products;
+    this.language = assets.info.loadedLanguage;
+    this.story = assets.json(`${this.dir}/story.json`);
+    this.episode = assets.json(`${this.dir}/${this.story.episode}`);
+    this.parts = this.story.parts;
+    this._docs = new Map();
+  }
+
+  document(manifest, file, format = null) {
+    const path = `${productDir(manifest)}/${file}`;
+    if (!this._docs.has(path)) {
+      const doc = this.assets.json(path);
+      if (format !== null && doc?.format !== format) throw new Error(`${path}: expected format ${format}`);
+      this._docs.set(path, doc);
+    }
+    return this._docs.get(path);
+  }
+
+  file(manifest, file) { return `${productDir(manifest)}/${file}`; }
+  get scene() { return this.document(this.parts.scene, "scene.json", FORMATS.scene); }
+  get playerSettings() { return this.assets.mono(this.scene.settings.playerSettings); }
+  get masterIds() { return this.assets.mono(this.scene.settings.masterIdSettings); }
+  get chat() { return this.parts.chat ? this.document(this.parts.chat, "chat.json", 1) : null; }
+  get crilips() {
+    const path = this.parts.crilips;
+    return path ? { descriptor: this.document(path, "crilips.json"), data: this.assets.arrayBuffer(this.file(path, "crilips.bin")) } : null;
+  }
+  get ui() { return this.document(this.parts.ui[this.language], "ui.json", FORMATS.ui); }
+  get fonts() { return this.document(this.parts.fonts[this.language], "fonts.json", FORMATS.fonts); }
+  get fontDir() { return productDir(this.parts.fonts[this.language]); }
+  get simpleui() { return this.parts.simpleui ? this.document(this.parts.simpleui[this.language], "ui.json", FORMATS.simpleui) : null; }
+  get host() {
+    const paths = Object.values(this.parts.host || {});
+    if (paths.length > 1) throw new Error("a story can have only one host product");
+    return paths.length ? this.document(paths[0], "host.json", FORMATS.host) : null;
+  }
+
+  resourceOptions() {
+    const docs = [this.scene, this.ui, this.fonts, this.simpleui, this.host,
+      ...Object.keys(this.parts.assets || {}).map((key) => this.asset(key))].filter(Boolean);
+    const shaders = {};
+    // Shader.Find uses the scene's registered name first. Materials always use their own shader object id,
+    // including bundle-local shaders whose Unity name is also registered by the scene.
+    for (const doc of docs) for (const [name, id] of Object.entries(doc.shaders || {})) shaders[name] ??= id;
+    return { shaders, bindings: docs.map((doc) => doc.bindings || {}) };
+  }
+
+  asset(address) {
+    const path = this.parts.assets?.[address];
+    if (!path) throw new Error(`story asset ${address}: not listed`);
+    return this.document(path, "asset.json", 1);
+  }
+
+  model(address) {
+    const path = this.parts.models?.[address];
+    if (!path) throw new Error(`story model ${address}: not listed`);
+    return { dir: productDir(path), doc: this.document(path, "model.json", 3) };
+  }
+
+  cues(sheet) {
+    const path = this.parts.sounds?.[sheet];
+    if (!path) throw new Error(`story cue sheet ${sheet}: not listed`);
+    const cues = this.document(path, "cues.json");
+    return Object.fromEntries(Object.entries(cues).map(([name, cue]) =>
+      [name, { ...cue, file: this.file(path, cue.file) }]));
+  }
+
+  video(address) {
+    const path = this.parts.videos?.[address];
+    if (!path) throw new Error(`story video ${address}: not listed`);
+    const doc = this.document(path, "video.json", 1);
+    return { ...doc, file: this.file(path, doc.file) };
+  }
+
+  videoFor(id) {
+    const master = this.episode.videos[id];
+    if (!master) throw new Error(`story video ${id}: no master row`);
+    return master._assetName?.trim() ? { ...this.video(`Cri/Video/${master._assetName}`), master } : { master };
+  }
+}
diff --git a/src/story/features/canvas.js b/src/story/features/canvas.js
index 0032d38..a7fadf5 100644
--- a/src/story/features/canvas.js
+++ b/src/story/features/canvas.js
@@ -1,9 +1,9 @@
 import { Animator } from "../../engine/anim.js";
-import { F, join } from "../../engine/core.js";
+import { F } from "../../engine/core.js";
 import { UIAffine, UIDraw, UIError, UIImage, UILayout, UIMesh, UINode, UISprite, UI_CLIP_TARGET, UI_STRIDE, uiColor32 } from "../../engine/ugui.js";
 import { StoryCommandError } from "../interfaces.js";
 import { StoryLayout } from "../ui-layout.js";
-import { AnimRecords } from "./clips.js";
+import { componentClass } from "../../engine/prefab.js";
 
 // uGUI prefab instances on the story's screen canvases (VideoCanvas, StillCanvas, FrameCanvas of UIAdvWidget): the
 // prefab node lists of frames.json / stills.json as RectTransform trees with their graphics, CanvasGroups, layout
@@ -16,8 +16,8 @@ import { AnimRecords } from "./clips.js";
 // A prefab record: {path, name, active, layer, localPosition, localRotation, localScale, rect, components} in
 // hierarchy order (parents first), components with `type` (engine) or `class` (MonoBehaviour).
 
-export const compOf = (rec, cls) => (rec.components || []).find((c) => (c.class || c.type) === cls) || null;
-export const compsOf = (rec, cls) => (rec.components || []).filter((c) => (c.class || c.type) === cls);
+export const compOf = (rec, cls) => (rec.components || []).find((c) => componentClass(c) === cls)?.fields || null;
+export const compsOf = (rec, cls) => (rec.components || []).filter((c) => componentClass(c) === cls).map((c) => c.fields);
 
 // ------------------------------------------------------------------------------------------------ nodes
 // UnityEngine.Quaternion -> the x / y rows of its rotation matrix (float32)
@@ -209,19 +209,18 @@ export const bindCanvasProperty = (root, b, extra = null) => {
 };
 
 // The Mecanim Animator of a prefab node (layer 0 of its controller, one clip per state; engine/anim.js) with the
-// normalized time of the current state. records: the file's AnimRecords (clips.js), which resolves controllers and
-// clips written once per file. A missing controller (m_Controller null) gives an Animator without states: HasState
+// normalized time of the current state. ObjectResources resolves controllers and clips with this prefab's bindings. A missing controller (m_Controller null) gives an Animator without states: HasState
 // is false for every state.
 // ENGINE: a state whose motion is missing or has zero length advances its normalized time as if one second long.
 export class CanvasAnimator {
-  constructor(node, comp, bind, name = node.path, records = new AnimRecords({}, UIError)) {
+  constructor(node, comp, bind, name = node.path, objects) {
     this.node = node; this.comp = comp;
-    const raw = records.controller(comp.m_Controller, node.path);
+    const ctrl = comp.m_Controller ? objects.controller(comp.m_Controller, node.prefabId, node.sourcePath) : null;
     this.animator = null;
-    if (raw) {
+    if (ctrl) {
       if (comp.m_UpdateMode !== 0 || comp.m_CullingMode !== 0 || comp.m_ApplyRootMotion)
         throw new UIError(`${node.path}: Animator settings outside the implemented subset`);
-      this.animator = new Animator(records.controllerOf(raw, node.path), bind, name);
+      this.animator = new Animator(ctrl, bind, name);
     }
     this.enabled = !!comp.m_Enabled;
     this.keepStateOnDisable = !!comp.m_KeepAnimatorStateOnDisable;
@@ -287,6 +286,8 @@ export class TransformNode {
 
   get anchoredPosition() { throw new UIError(`${this.path}: not a RectTransform`); }
   get sizeDelta() { throw new UIError(`${this.path}: not a RectTransform`); }
+  component(cls) { return this.rec.components.find((c) => componentClass(c) === cls) || null; }
+  fields(cls) { return this.component(cls)?.fields || null; }
 
   layoutIn(pr, parentMatrix) {
     const [m00, m10, m01, m11] = quatRows(this.localRotation), sx = this.localScale.x, sy = this.localScale.y;
@@ -305,8 +306,9 @@ const LAYOUT_GROUPS = ["HorizontalLayoutGroup", "VerticalLayoutGroup", "GridLayo
 const TMP_CLASSES = ["TextMeshProUGUI", "RubyTextMeshProUGUI", "RubyEmojiTextMeshProUGUI"];
 
 export class CanvasPrefab {
-  constructor(nodes, parent, canvas) {
+  constructor(nodes, parent, canvas, prefabId = null) {
     this.canvas = canvas;
+    this.source = prefabId ? canvas.objects.prefab(prefabId) : null;
     this.nodes = new Map();
     for (const rec of nodes) {
       const cut = rec.path.lastIndexOf("/");
@@ -321,6 +323,9 @@ export class CanvasPrefab {
         n = new CanvasNode({ ...rec, canvasGroup: compOf(rec, "CanvasGroup") }, p || null);
         this._components(n, rec);
       }
+      n.prefabId = prefabId;
+      n.sourcePath = rec.path;
+      n.componentId = (c) => `${prefabId.slice(0, prefabId.lastIndexOf(":"))}:${c.pathId}`;
       const particles = PARTICLE_COMPONENTS.filter((cls) => compOf(rec, cls));
       if (particles.length) n.particleComponents = particles;
       this.nodes.set(rec.path, n);
@@ -343,8 +348,7 @@ export class CanvasPrefab {
     // walk and LayoutElement.ignoreLayout), and the enabled ones on the node
     const lgClass = LAYOUT_GROUPS.find((cls) => compOf(rec, cls)), lg = lgClass ? compOf(rec, lgClass) : null;
     const le = compOf(rec, "LayoutElement");
-    n.rec.layoutGroup = lg ? { ...lg, class: lgClass } : undefined;
-    n.rec.layoutElement = le || undefined;
+    n.ignoreLayout = !!le?.m_IgnoreLayout;
     if (lg && lg.m_Enabled) n.layoutGroup = { ...lg, class: lgClass };
     if (le && le.m_Enabled) n.layoutElement = le;
     const csf = compOf(rec, "ContentSizeFitter");
@@ -362,7 +366,7 @@ export class CanvasPrefab {
   }
 
   // a component reference {component, gameObject} -> the node
-  ref(r) { return r ? this.node(r.gameObject) : null; }
+  ref(r) { return r ? this.node(this.source ? this.source.pathOf(r) : r.gameObject || r.transform) : null; }
 }
 
 // ------------------------------------------------------------------------------------------------ screen canvas
@@ -383,7 +387,8 @@ export const clampedCanvasSize = (scaler, width, height) => {
 // One camera canvas of UIAdvWidget: a root node laid out over the canvas units, its content drawn in hierarchy order
 // with the UI shaders. `sprite(record)` / `material(record)` collect what the GL load needs.
 export class ScreenCanvas {
-  constructor(name, { sortingOrder, scaler }) {
+  constructor(name, { sortingOrder, scaler }, objects) {
+    this.objects = objects;
     this.name = name; this.sortingOrder = sortingOrder; this.scaler = scaler;
     this.root = new CanvasNode({ path: name, name, active: true, localPosition: { x: 0, y: 0, z: 0 },
                                  localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 },
@@ -399,45 +404,27 @@ export class ScreenCanvas {
 
   get refPPU() { return this.scaler.m_ReferencePixelsPerUnit; }
 
-  sprite(s) {
+  sprite(ref) {
+    const s = this.objects.sprite(ref);
     if (!s) return null;
-    const tex = s.texture, key = `${s.sprite}@${tex.texture}`;
-    if (!this.sprites.has(key)) {
-      if (s.downscaleMultiplier !== undefined && s.downscaleMultiplier !== 1) throw new UIError(`sprite ${s.sprite}: atlas variant scale`);
-      const sp = new UISprite(s.sprite, { rect: s.rect, border: s.border, pixelsPerUnit: s.pixelsToUnits, pivot: s.pivot,
-                                          textureRect: s.textureRect, textureRectOffset: s.textureRectOffset },
-                              { width: tex.width, height: tex.height, name: tex.texture,
-                                wrapU: tex.settings ? tex.settings.m_WrapU : 1, wrapV: tex.settings ? tex.settings.m_WrapV : 1 });
-      sp.packed = !!((s.settingsRaw | 0) & 1);                   // SpriteSettings.packed
-      this.sprites.set(key, sp);
-      this.textures.set(tex.texture, tex);
+    if (!this.sprites.has(s.id)) {
+      if (s.downscaleMultiplier !== undefined && s.downscaleMultiplier !== 1) throw new UIError(`sprite ${s.id}: atlas variant scale`);
+      const sp = new UISprite(s.id, { ...s, pixelsPerUnit: s.pixelsToUnits }, s.texture);
+      sp.packed = !!((s.settingsRaw | 0) & 1);
+      this.sprites.set(s.id, sp);
+      this.textures.set(s.texture.id, s.texture);
     }
-    return this.sprites.get(key);
+    return this.sprites.get(s.id);
   }
 
-  // a sprite of the story UI data (ui/ui.json `sprites` / `textures`, texture paths under `dir`)
-  uiSprite(doc, name, dir) {
-    if (!name) return null;
-    const key = `ui:${name}`;
-    if (!this.sprites.has(key)) {
-      const s = doc.sprites[name], t = s ? doc.textures[s.texture] : null;
-      if (!s || !t) throw new UIError(`sprite ${name} not in the story UI data`);
-      const path = join(dir, t.texture), desc = { ...t, texture: path };
-      const sp = new UISprite(name, s, { ...desc, name: path, wrapU: t.settings ? t.settings.m_WrapU : 1,
-                                         wrapV: t.settings ? t.settings.m_WrapV : 1 });
-      this.sprites.set(key, sp);
-      this.textures.set(path, desc);
+  material(ref) {
+    const m = this.objects.material(ref);
+    if (!m) return null;
+    if (!this.materials.has(m.id)) {
+      this.materials.set(m.id, m);
+      for (const t of Object.values(m.textures || {})) if (t.texture) this.textures.set(t.texture.id, t.texture);
     }
-    return this.sprites.get(key);
-  }
-
-  material(m) {
-    if (!m.shader || !m.shader.shader) throw new UIError(`material ${m.material}: no shader`);
-    if (!this.materials.has(m.material)) {
-      this.materials.set(m.material, m);
-      for (const t of Object.values(m.textures || {})) if (t.texture) this.textures.set(t.texture.texture, t.texture);
-    }
-    return this.materials.get(m.material);
+    return this.materials.get(m.id);
   }
 
   canvasSize(width, height) { return clampedCanvasSize(this.scaler, width, height); }
@@ -471,7 +458,7 @@ export class ScreenCanvas {
           const [x, y, z] = m3Apply(n.matrix3, v.x, v.y), o = i * UI_STRIDE;
           verts[o] = x; verts[o + 1] = y; verts[o + 2] = P ? z : 0;
         });
-        out.push({ node: n, material: img.material, texture: sp ? sp.texture.name : null, mesh,
+        out.push({ node: n, material: img.material, texture: sp ? sp.texture.id : null, mesh,
                    verts, idx: Uint32Array.from(mesh.idx), ...(img.glTex ? { glTex: img.glTex } : {}) });
       }
       const t = n.text && n.text.enabled ? n.text : null;
@@ -513,8 +500,8 @@ export const viewProjection = (fov, W, H) => {
 // defaults. A custom Image material keeps its own properties; _MainTex is the sprite's texture (Image.mainTexture).
 export class CanvasGL {
   // textUI: the story UI, whose text materials, glyph pages and shader programs draw the canvas texts
-  constructor(gl, lib, assets, textUI = null) {
-    this.gl = gl; this.lib = lib; this.assets = assets; this.textUI = textUI;
+  constructor(gl, objects, textUI = null) {
+    this.gl = gl; this.lib = objects.lib; this.objects = objects; this.textUI = textUI;
     this.tex = new Map(); this.mats = new Map();
     this.solid = null; this.buf = null; this.defaultMaterial = null;
   }
@@ -525,16 +512,16 @@ export class CanvasGL {
       white: GLTex.solid(gl, [255, 255, 255, 255], "white"), black: GLTex.solid(gl, [0, 0, 0, 255], "black"),
       gray: GLTex.solid(gl, [128, 128, 128, 255], "gray"), bump: GLTex.solid(gl, [128, 128, 255, 255], "bump"),
     };
-    this.defaultMaterial = this._material({ material: "Default UI Material", shader: { shader: "UI/Default" }, keywords: [] });
+    this.defaultMaterial = this._material({ material: "Default UI Material", shader: "UI/Default", keywords: [] });
     for (const c of canvases) {
-      for (const [p, desc] of c.textures) if (!this.tex.has(p)) this.tex.set(p, await GLTex.load(gl, "", desc, this.assets));
-      for (const m of c.materials.values()) if (!this.mats.has(m.material)) this.mats.set(m.material, this._material(m));
+      for (const id of c.textures.keys()) if (!this.tex.has(id)) this.tex.set(id, await this.objects.texture(id));
+      for (const m of c.materials.values()) if (!this.mats.has(m.id)) this.mats.set(m.id, this._material(m));
     }
     this.buf = { vao: gl.createVertexArray(), vbo: gl.createBuffer(), ibo: gl.createBuffer() };
   }
 
   _material(m) {
-    const shader = m.shader.shader, defaults = this.lib.defaults(shader, this.solid);
+    const shader = m.shader, defaults = this.lib.defaults(shader, this.solid);
     const num = Object.fromEntries(Object.entries(defaults).filter(([, v]) => typeof v === "number"));
     const out = { shader, keywords: m.keywords || [], floats: { ...num, ...(m.floats || {}) }, colors: m.colors || {}, defaults,
                   textures: m.textures || {} };
@@ -551,7 +538,7 @@ export class CanvasGL {
     }
     for (const it of items) {
       if (it.text) { this._drawText(it, globals); continue; }
-      const mat = it.material ? this.mats.get(it.material.material) : this.defaultMaterial;
+      const mat = it.material ? this.mats.get(it.material.id) : this.defaultMaterial;
       const tex = it.glTex ? it.glTex() : it.texture ? this.tex.get(it.texture) : this.solid.white;
       if (!tex) continue;                   // a graphic whose texture is not there yet (a video before its first frame)
       const st = mat.textures._MainTex;
diff --git a/src/story/features/chat.js b/src/story/features/chat.js
index 954c69d..0ebef8d 100644
--- a/src/story/features/chat.js
+++ b/src/story/features/chat.js
@@ -1,3 +1,4 @@
+import { uiTextBinding } from "../ui-objects.js";
 import { F } from "../../engine/core.js";
 import { uiCanvasSize } from "../../engine/ugui.js";
 import { StoryCommandError } from "../interfaces.js";
@@ -12,7 +13,7 @@ import { featureSlot, featureState } from "./state.js";
 // phone's foreground entry on the field renderer (AdvForegroundFieldRendererEntry). The view does what AdvChatView
 // does to the window's objects: screen modes and slides, the bubbles (copies of the window's node templates) and the
 // lock-screen timeline, identities and read labels, the typing box, the scroll positions. With the story UI's chat data
-// (ui/ui.json `chatWidget`, ui/fonts.json `chatTexts`) the window is a laid-out uGUI tree (ui-chat.js) and a drawing
+// (story.ui `chatWidget`, story.fonts `texts`) the window is a laid-out uGUI tree (ui-chat.js) and a drawing
 // session draws it on the ADV camera; without it (a headless session over other data) the same state is kept without
 // the layout, the scroll tweens running on a 0 position.
 
@@ -26,7 +27,7 @@ export const CHAT_WIDGET = Object.freeze({
   typingTextBoxMinHeight: 63, screenModeTransitionDuration: 0.18, screenModeTransitionEase: 9,
   incomingCallPositionOffset: Object.freeze({ x: 0, y: 0 }), targetPosition: Object.freeze({ x: 0, y: 0 }),
 });
-// the AdvChatView record of ui/ui.json `chatWidget` in CHAT_WIDGET's form
+// the AdvChatView record of story.ui `chatWidget` in CHAT_WIDGET's form
 const widgetConfig = (phone) => {
   if (!phone) return CHAT_WIDGET;
   const v = phone.chatView, t = phone.target.anchoredPosition;
@@ -126,7 +127,7 @@ export class ChatWindow {
     this.nodes = built.nodes; this.root = built.root;
     const w = compOf(this.root.raw, "AdvChatWindow");
     if (!w) throw new StoryCommandError(`chat window ${name}: no AdvChatWindow`);
-    const node = (r) => (r ? this._node(r.gameObject || r.transform) : null);
+    const node = (r) => (r ? this._node(host.pathOf(r)) : null);
     this.normal = node(w._normalScreenObject); this.lock = node(w._lockScreenObject); this.incoming = node(w._incomingCallObject);
     this.chatNodeParent = node(w._chatNodeParent); this.lockChatNodeParent = node(w._lockChatNodeParent);
     this.scrollRect = node(w._scrollRect); this.lockScrollRect = node(w._lockScrollRect);
@@ -181,7 +182,7 @@ export class ChatWindow {
   }
 
   // RefreshStatusTexts: LocalizeText.SetMasterTextId of the two status texts (their text: the MasterText in the
-  // language, ui/ui.json `chatStatusTexts`)
+  // language, story.ui `chatStatusTexts`)
   refreshStatusTexts(statusTexts) {
     this.text.status = [this.statusKeys.incoming, this.statusKeys.lock];
     for (const [n, key] of this.statusTexts) {
@@ -270,7 +271,7 @@ const chatNodeParts = (root) => {
   const c = compOf(root.raw, "AdvMyChatNode") || compOf(root.raw, "AdvOtherChatNode");
   const get = (r) => {
     if (!r) return null;
-    const n = root.lookup.get(r.gameObject || r.transform);
+    const n = root.lookup.get(root.pathOf(r));
     if (!n || (n !== root && !isUnder(n, root))) throw new StoryCommandError(`${root.src}: ${r.gameObject || r.transform} is outside the chat node`);
     return n;
   };
@@ -317,7 +318,7 @@ const typingTask = (loop, plain, total, delaySec, setVisible, cancelled) => {
 };
 
 export class ChatView {
-  // phone: the laid-out widget (ChatCanvasUI) or null; statusTexts: ui/ui.json `chatStatusTexts`; sprite(kind, name):
+  // phone: the laid-out widget (ChatCanvasUI) or null; statusTexts: story.ui `chatStatusTexts`; sprite(kind, name):
   // a chat icon ("icons") or stamp ("stamps") sprite by asset name, or null
   constructor(ctx, phone = null, statusTexts = null, sprite = () => null) {
     this.ctx = ctx;
@@ -495,7 +496,7 @@ export class ChatView {
   _scrollRectOf(node) {
     const s = node.scrollRect;
     if (!s) throw new StoryCommandError(`${node.path}: no ScrollRect`);
-    const w = this.window, get = (r) => (r ? w._node(r.transform || r.gameObject) : null);
+    const w = this.window, get = (r) => (r ? w._node(w.host.pathOf(r)) : null);
     return new ChatScrollRect(node, get(s.m_Content), get(s.m_Viewport), () => this._layout());
   }
 
@@ -946,19 +947,18 @@ export class ChatView {
 // rows of the chat rows) and the session's chat fields. `ui` = the story UI (its chat widget, status texts and the
 // chat windows' text bindings; null or without them: not laid out).
 export class StoryChat {
-  constructor(ctx, doc, ui = null) {
-    this.ctx = ctx; this.doc = doc;
-    this.chats = new Map(Object.entries(doc.chats || {}).map(([k, v]) => [Number(k), v]));
+  constructor(ctx, data, ui = null) {
+    this.ctx = ctx; this.data = data;
+    this.chats = new Map(Object.entries(data.story.chats || {}).map(([k, v]) => [Number(k), v]));
     this.windows = new Map(); this.icons = new Map(); this.stamps = new Map();
-    const bindings = ui && ui.fonts && ui.fonts.chatTexts ? ui.fonts.chatTexts : null;
-    const widget = ui && ui.doc && ui.doc.chatWidget ? ui.doc.chatWidget : null;
-    this.phone = bindings && widget ? new ChatCanvasUI(widget) : null;
-    this.sprites = new Map();                                          // chat texture path -> descriptor (GL load)
+    this.phone = ui?.fonts?.texts && data.ui.chatWidget ? new ChatCanvasUI(ctx.objects.prefab(data.ui.chatWidget)) : null;
+    this.sprites = new Map();
     this._spriteCache = new Map();
-    const host = (name) => ({
+    const host = (id) => ({
+      prefabId: id, pathOf: (ref) => ctx.objects.prefab(id).pathOf(ref),
       sprite: (s) => (this.phone ? this._chatSprite(s) : null),
-      binding: (src) => (this.phone ? bindings[name][src] || null : null),
-      textHost: ui, languageMode: ui && ui.language ? ui.language.mode : 0, requireTexts: !!this.phone, visual: !!this.phone,
+      binding: (src, node) => this.phone ? uiTextBinding(node, ui.fonts) : null,
+      textHost: ui, languageMode: ui?.language?.mode || 0, requireTexts: !!this.phone, visual: !!this.phone,
     });
     const addresses = new Set();
     for (const c of ctx.episode.commands) {
@@ -969,18 +969,16 @@ export class StoryChat {
         const name = chat._chatWindowAssetName;
         if (!addresses.has(name)) {                                    // one load per address, kept for the first id
           addresses.add(name);
-          const rec = (doc.windows || {})[name];
-          if (!rec) throw new StoryCommandError(`chat window ${name} not in the chat data`);
-          if (this.phone && !bindings[name]) throw new StoryCommandError(`chat window ${name}: no text bindings in the story UI data`);
-          if (!this.windows.has(id)) this.windows.set(id, new ChatWindow(id, name, rec, host(name)));
+          const root = this.assetRoot(`Adv/Chat/Prefabs/${name}`), rec = ctx.assets.prefab(root);
+          if (!this.windows.has(id)) this.windows.set(id, new ChatWindow(id, name, rec, host(root)));
         }
       }
       if ((c.cmd === "ChatTalk" || c.cmd === "ChatStamp") && chat && chat._chatIconAssetName && !this.icons.has(id)) {
-        if (!(doc.icons || {})[chat._chatIconAssetName]) throw new StoryCommandError(`chat icon ${chat._chatIconAssetName} not in the chat data`);
+        this.assetRoot(`Adv/Chat/Icon/${chat._chatIconAssetName}`);
         this.icons.set(id, chat._chatIconAssetName);
       }
       if (c.cmd === "ChatStamp" && (c.TargetAssetName ?? "").trim() && !this.stamps.has(c.TargetAssetName)) {
-        if (!(doc.stamps || {})[c.TargetAssetName]) throw new StoryCommandError(`chat stamp ${c.TargetAssetName} not in the chat data`);
+        this.assetRoot(`Adv/Chat/Stamp/${c.TargetAssetName}`);
         this.stamps.set(c.TargetAssetName, c.TargetAssetName);
       }
     }
@@ -993,12 +991,13 @@ export class StoryChat {
   // a chat sprite record -> UISprite (its texture registered for the GL load)
   _chatSprite(s) {
     if (!s) return null;
-    const key = `${s.sprite}@${s.texture && s.texture.texture}`;
+    s = this.ctx.objects.sprite(s);
+    const key = s.id;
     let sp = this._spriteCache.get(key);
     if (!sp) {
       sp = chatSprite(s);
       this._spriteCache.set(key, sp);
-      this.sprites.set(sp.texture.name, sp.desc);
+      this.sprites.set(sp.texture.id, sp.desc);
     }
     return sp;
   }
@@ -1006,9 +1005,13 @@ export class StoryChat {
   // an icon or stamp of chat.json by asset name, as a sprite (null without the layout)
   sprite(kind, name) {
     if (!this.phone || !name) return null;
-    const rec = (this.doc[kind] || {})[name];
-    if (!rec) throw new StoryCommandError(`chat ${kind === "icons" ? "icon" : "stamp"} ${name} not in the chat data`);
-    return this._chatSprite(rec);
+    return this._chatSprite(this.assetRoot(`Adv/Chat/${kind === "icons" ? "Icon" : "Stamp"}/${name}`));
+  }
+
+  assetRoot(address) {
+    const product = this.data.asset(address);
+    if (product.objects.length !== 1) throw new StoryCommandError(`${address}: expected one root object`);
+    return product.objects[0];
   }
 
   // The texts the laid-out phone will show, each checked against the chat window texts that show it (the texts of every
@@ -1062,10 +1065,10 @@ export class StoryChat {
   }
 
   // the GL resources of the drawn phone: the chat sprites' textures (windows, and the icons and stamps the rows use)
-  async loadGL(gl, assets) {
+  async loadGL(gl) {
     for (const id of this.icons.keys()) this.sprite("icons", this.icons.get(id));
     for (const name of this.stamps.keys()) this.sprite("stamps", name);
-    this.gl = new ChatCanvasGL(gl, this.ctx.ui, assets);
+    this.gl = new ChatCanvasGL(gl, this.ctx.ui, this.ctx.objects);
     await this.gl.load(this.sprites);
   }
 
@@ -1108,15 +1111,13 @@ export const storyChat = (ctx) => featureState(ctx).chat || null;
 export const loadChat = async (ctx) => {
   const uses = ctx.episode.commands.some((c) => !c.IgnoreData && c.cmd.startsWith("Chat"));
   if (!uses) return null;
-  const file = ctx.story && ctx.story.chat;
-  if (!file) throw new StoryCommandError("the story data has no chat.json");
   const s = featureState(ctx);
-  const chat = featureSlot(ctx, "chat", () => new StoryChat(ctx, ctx.assets.json(file), ctx.ui || null));
+  const chat = featureSlot(ctx, "chat", () => new StoryChat(ctx, ctx.data, ctx.ui || null));
   if (chat.phone) chat.checkTexts();
   if (ctx.gl) {
-    if (!chat.phone) throw new StoryCommandError("the chat phone needs the story UI's chat widget and chat window text bindings (ui/ui.json chatWidget, ui/fonts.json chatTexts)");
+    if (!chat.phone) throw new StoryCommandError("the chat phone needs the story UI's chat widget and chat window text bindings (story.ui chatWidget, story.fonts texts)");
     if (!ctx.renderer) throw new StoryCommandError("the chat phone needs the story renderer");
-    await chat.loadGL(ctx.gl, ctx.assets);
+    await chat.loadGL(ctx.gl);
     const source = () => chat.fieldItems();
     ctx.renderer.addFieldItems(source);
     s.disposers.push(() => ctx.renderer.removeFieldItems(source));
diff --git a/src/story/features/clips.js b/src/story/features/clips.js
deleted file mode 100644
index fbb0b28..0000000
--- a/src/story/features/clips.js
+++ /dev/null
@@ -1,96 +0,0 @@
-import { AnimClip, AnimController } from "../../engine/anim.js";
-
-// Animator controllers and clips of one story data file (frames.json, stills.json, effects.json). The exporter
-// writes each controller and clip in full the first time the file uses it and as a reference after that
-// ({controller: name} / {clip: name}), also across prefabs of the same file; these references resolve here. Two full
-// records under one name that differ make the name ambiguous: a reference to it raises.
-const AMBIGUOUS = Symbol("ambiguous");
-
-const isFullClip = (x) => typeof x.clip === "string" && Object.keys(x).length > 1;
-const isFullController = (x) => typeof x.controller === "string" && Array.isArray(x.layers);
-
-export class AnimRecords {
-  constructor(doc, Err = Error) {
-    this.Err = Err;
-    this.controllers = new Map();
-    this.clips = new Map();
-    const add = (map, name, rec) => {
-      const seen = map.get(name);
-      if (seen === undefined) map.set(name, rec);
-      else if (seen !== AMBIGUOUS && seen !== rec && JSON.stringify(seen) !== JSON.stringify(rec)) map.set(name, AMBIGUOUS);
-    };
-    const walk = (x) => {
-      if (Array.isArray(x)) { for (const v of x) walk(v); return; }
-      if (!x || typeof x !== "object") return;
-      if (isFullController(x)) add(this.controllers, x.controller, x);
-      else if (isFullClip(x)) add(this.clips, x.clip, x);
-      for (const v of Object.values(x)) walk(v);
-    };
-    walk(doc);
-  }
-
-  _get(map, kind, name, where) {
-    const r = map.get(name);
-    if (r === AMBIGUOUS) throw new this.Err(`${where}: two different ${kind}s named ${name}`);
-    if (!r) throw new this.Err(`${where}: ${kind} ${name} not in the data`);
-    return r;
-  }
-
-  // Animator.m_Controller -> the full controller record, or null when the Animator has none
-  controller(raw, where) {
-    if (!raw) return null;
-    if (typeof raw.controller !== "string") throw new this.Err(`${where}: Animator controller not exported`);
-    return raw.layers ? raw : this._get(this.controllers, "controller", raw.controller, where);
-  }
-
-  // the normalized controller (AnimController.fromMecanim) with its clips: the controller's own full records first
-  controllerOf(raw, where) {
-    const own = ownClips(raw, (name) => new this.Err(`${where}: two clips named ${name}`));
-    const made = new Map();
-    return AnimController.fromMecanim(raw, ({ clip: key }) => {
-      if (!made.has(key)) made.set(key, AnimClip.fromMecanim(own.get(key) || this._get(this.clips, "clip", key, where), key));
-      return made.get(key);
-    });
-  }
-}
-
-// the full clip records of a full controller's `clips` by name (two different ones under one name raise)
-const ownClips = (raw, err) => {
-  const own = new Map();
-  for (const c of raw.clips || []) {
-    if (!isFullClip(c)) continue;
-    const seen = own.get(c.clip);
-    if (seen && JSON.stringify(seen) !== JSON.stringify(c)) throw err(c.clip);
-    if (!seen) own.set(c.clip, c);
-  }
-  return own;
-};
-
-// The references of a story data file that AnimRecords cannot resolve: a controller or clip reference without a full
-// record of its name in the file, or with two different ones (a clip reference in a controller's `clips` resolves to
-// that controller's own full record first). Returns the problems as messages, each once.
-export const animRecordProblems = (doc) => {
-  const r = new AnimRecords(doc), out = new Set();
-  const need = (map, kind, name) => {
-    const v = map.get(name);
-    if (v === undefined) out.add(`${kind} ${name}: referenced, not in the file`);
-    else if (v === AMBIGUOUS) out.add(`${kind} ${name}: referenced, two different full records in the file`);
-  };
-  const walk = (x, own) => {
-    if (Array.isArray(x)) { for (const v of x) walk(v, own); return; }
-    if (!x || typeof x !== "object") return;
-    if (isFullController(x)) {
-      let mine = new Map();
-      try { mine = ownClips(x, (name) => new Error(name)); } catch (e) {
-        out.add(`controller ${x.controller}: two different clips named ${e.message}`);
-      }
-      for (const [k, v] of Object.entries(x)) walk(v, k === "clips" ? mine : null);
-      return;
-    }
-    if (typeof x.controller === "string") need(r.controllers, "controller", x.controller);
-    else if (typeof x.clip === "string" && !isFullClip(x) && !(own && own.has(x.clip))) need(r.clips, "clip", x.clip);
-    for (const v of Object.values(x)) walk(v, null);
-  };
-  walk(doc, null);
-  return [...out];
-};
diff --git a/src/story/features/effect.js b/src/story/features/effect.js
index 6bdd65c..3f70c4a 100644
--- a/src/story/features/effect.js
+++ b/src/story/features/effect.js
@@ -1,12 +1,11 @@
 import { AnimTargets, Animator } from "../../engine/anim.js";
 import { F } from "../../engine/core.js";
 import { mat4, quat, Transform } from "../../engine/math.js";
-import { Prefab } from "../../engine/prefab.js";
+import { Prefab, componentClass } from "../../engine/prefab.js";
 import { FxMaterials, FxParticleSystem, PS_STOP } from "../../engine/particles.js";
 import { UnityRandom } from "../../engine/random.js";
 import { FxSpriteRenderer } from "../../live/fx-effects.js";
 import { StoryCommandError } from "../interfaces.js";
-import { AnimRecords } from "./clips.js";
 import { featureSlot, featureState } from "./state.js";
 
 // Particle / Animator effects of the Effect command (AdvParticleEffect instances of effects.json, one per TargetName:
@@ -32,9 +31,9 @@ const CAMERA_LAYER = { 1: 6, 3: 7, 5: 8, 7: 9, 9: 10 };          // AdvPositionT
 // ENGINE: a mesh without vertex colours reads colour (1, 1, 1, 1) (FxMaterial's constant white).
 export class EffectMeshRenderer {
   constructor(filter, renderer, transform, { materials = null, name = "" } = {}) {
-    const m = filter.m_Mesh;
+    const m = materials ? materials.mesh(filter.m_Mesh) : filter.m_Mesh;
     if (!m || !m.vertices || !m.submeshes) throw new StoryCommandError(`${name}: MeshFilter without mesh data`);
-    const mats = renderer.m_Materials || [];
+    const mats = (renderer.m_Materials || []).map((m) => materials ? materials.record(m) : m);
     if (!mats.length || mats.some((x) => !x)) throw new StoryCommandError(`${name}: MeshRenderer without its materials`);
     if (m.submeshes.length > mats.length) throw new StoryCommandError(`${name}: more submeshes than materials`);
     this.name = name;
@@ -43,8 +42,9 @@ export class EffectMeshRenderer {
     this.sortingLayer = renderer.m_SortingLayer | 0;
     this.sortingOrder = renderer.m_SortingOrder | 0;
     this.materialRecords = mats.slice(0, m.submeshes.length);
+    this.materialRefs = renderer.m_Materials.slice(0, m.submeshes.length);
     this.materials = materials;
-    if (materials) for (const r of this.materialRecords) materials.get(r);
+    if (materials) for (const r of this.materialRefs) materials.get(r);
     const n = m.vertices.length, has = (k) => Array.isArray(m[k]) && m[k].length === n;
     const streams = [["in_POSITION0", 3, m.vertices], has("normals") && ["in_NORMAL0", 3, m.normals],
                      has("colors") && ["in_COLOR0", 4, m.colors], has("uv0") && ["in_TEXCOORD0", 2, m.uv0]].filter(Boolean);
@@ -77,7 +77,7 @@ export class EffectMeshRenderer {
     if (!this.enabled) return null;
     const M = this.transform.localToWorld(), c = this.worldCenter(M);
     const distance = camPos ? Math.hypot(c[0] - camPos[0], c[1] - camPos[1], c[2] - camPos[2]) : 0;
-    const mat = this.materials ? this.materials.get(this.materialRecords[0]) : null;
+    const mat = this.materials ? this.materials.get(this.materialRefs[0]) : null;
     const rq = this.materialRecords[0].renderQueue;
     return { sortingLayer: this.sortingLayer, sortingOrder: this.sortingOrder, queue: mat ? mat.queue : (rq >= 0 ? rq : null),
              distance, name: this.name, draw: (ctx) => this.draw(ctx, M) };
@@ -85,7 +85,7 @@ export class EffectMeshRenderer {
 
   draw(ctx, M = this.transform.localToWorld()) {
     if (!this.materials) return;
-    this.parts.forEach((part, i) => this.materials.get(this.materialRecords[i]).draw(ctx, part, M, {}));
+    this.parts.forEach((part, i) => this.materials.get(this.materialRefs[i]).draw(ctx, part, M, {}));
   }
 }
 
@@ -94,13 +94,13 @@ export const CHARACTER_SORT_STRIDE = 1000;
 
 // AdvParticleEffect with its prefab instance
 export class AdvParticleEffect {
-  // exported: the prefab record ({key, nodes}); opts {materials: FxMaterials | null, rng: UnityRandom, parent: Transform,
-  // records: AnimRecords of the data file}. A stage's particle group effect is a GameObject inside the stage prefab:
+  // prefab: the canonical Prefab; objects: the shared ObjectResources. A stage's particle group effect is a GameObject inside the stage prefab:
   // opts.prefab (the stage's engine/prefab.js Prefab) and opts.rootPath (the effect's GameObject path) build it over
   // that subtree; setParentActive() then carries the activity of the GameObjects above it.
-  constructor(name, exported, { materials = null, rng = null, parent = null, records = null, prefab = null, rootPath = null } = {}) {
+  constructor(name, prefab, { materials = null, rng = null, parent = null, objects, rootPath = null } = {}) {
     this.name = name;
-    const pf = this.prefab = prefab || new Prefab(exported);
+    const pf = this.prefab = prefab;
+    this.objects = objects;
     const rootKey = rootPath ?? pf.root.name;
     const root = pf.transform(rootKey);
     if (parent) root.setParent(parent);
@@ -120,7 +120,7 @@ export class AdvParticleEffect {
       this.order.push(e);
     }
     this.rootEntry = this.entries.get(rootKey);
-    const cls = (c) => c.class || c.type;
+    const cls = componentClass;
     this.systems = []; this.renderers = [];
     let comp = null, animatorComp = null;
     for (const e of this.order) {
@@ -129,23 +129,23 @@ export class AdvParticleEffect {
         const k = cls(c);
         if (k === "ParticleSystem") {
           const r = comps.find((x) => cls(x) === "ParticleSystemRenderer") || null;
-          e.system = new FxParticleSystem(c, r, e.transform, { rng, materials, name: `${name}:${e.path}` });
+          e.system = new FxParticleSystem(c.fields, r && r.fields, e.transform, { rng, materials, name: `${name}:${e.path}` });
           this.systems.push(e.system);
           if (r) this.renderers.push({ kind: "particle", entry: e, target: e.system });
         } else if (k === "SpriteRenderer") {
-          e.sprite = new FxSpriteRenderer(c, e.transform, { materials, name: `${name}:${e.path}` });
+          e.sprite = new FxSpriteRenderer(c.fields, e.transform, { materials, name: `${name}:${e.path}` });
           this.renderers.push({ kind: "sprite", entry: e, target: e.sprite });
         } else if (k === "MeshFilter") {
           const r = comps.find((x) => cls(x) === "MeshRenderer");
           if (!r) throw new StoryCommandError(`${name}:${e.path}: MeshFilter without a MeshRenderer not implemented`);
-          e.mesh = new EffectMeshRenderer(c, r, e.transform, { materials, name: `${name}:${e.path}` });
+          e.mesh = new EffectMeshRenderer(c.fields, r.fields, e.transform, { materials, name: `${name}:${e.path}` });
           this.renderers.push({ kind: "mesh", entry: e, target: e.mesh });
         } else if (k === "MeshRenderer") {
           if (!comps.some((x) => cls(x) === "MeshFilter")) throw new StoryCommandError(`${name}:${e.path}: MeshRenderer without a MeshFilter`);
         } else if (k === "Animator") {
-          if (!animatorComp) { animatorComp = c; this.animatorEntry = e; }      // GetComponentInChildren<Animator>(true)
+          if (!animatorComp) { animatorComp = c.fields; this.animatorEntry = e; }      // GetComponentInChildren<Animator>(true)
         } else if (k === "AdvParticleEffect") {
-          comp = c;
+          comp = c.fields;
         } else if (k !== "ParticleSystemRenderer") {
           throw new StoryCommandError(`${name}:${e.path}: component ${k} not implemented`);
         }
@@ -155,15 +155,15 @@ export class AdvParticleEffect {
     // ParticleSystem.Play / Stop (withChildren): the nearest systems below each system, hierarchy order
     const below = (e, out) => { for (const c of e.children) { if (c.system) out.push(c.system); else below(c, out); } return out; };
     for (const e of this.order) if (e.system) e.system.children = below(e, []);
-    for (const e of this.order) if (e.system && e.system.subEmitters.length) e.system.linkSubEmitters((ref) => { const x = this.entries.get(ref.gameObject); return x ? x.system : null; });
-    const main = this.entries.get(comp._particleSystem && comp._particleSystem.gameObject);
+    for (const e of this.order) if (e.system && e.system.subEmitters.length) e.system.linkSubEmitters((ref) => { const x = this.entries.get(pf.pathOf(ref)); return x ? x.system : null; });
+    const main = this.entries.get(pf.pathOf(comp._particleSystem));
     if (!main || !main.system) throw new StoryCommandError(`${name}: _particleSystem missing`);
     this.particleSystem = main.system;
     // CacheParticleSystems: every system (inactive included) with its serialized simulation speed
     this.defaultSpeeds = this.systems.map((s) => s.main.simulationSpeed);
     // CacheAnimator
     this.animator = null; this.animatorOn = false; this.defaultAnimatorSpeed = 1;
-    if (animatorComp) this._buildAnimator(animatorComp, records || new AnimRecords(exported || {}, StoryCommandError));
+    if (animatorComp) this._buildAnimator(animatorComp);
     // CacheRenderers: default sort orders and their relative ranks
     this.defaultSortOrders = this.renderers.map((r) => r.target.sortingOrder);
     const pos = [...new Set(this.defaultSortOrders.filter((o) => o >= 1))].sort((a, b) => a - b);
@@ -176,12 +176,11 @@ export class AdvParticleEffect {
     for (const e of this.order) this._propagate(e);
   }
 
-  _buildAnimator(c, records) {
+  _buildAnimator(c) {
     if (c.m_UpdateMode !== 0 || c.m_ApplyRootMotion || c.m_KeepAnimatorStateOnDisable)
       throw new StoryCommandError(`${this.name}: Animator settings not implemented`);
-    const raw = records.controller(c.m_Controller, this.name);
-    if (!raw) return;                                                   // no controller: no states
-    const ctrl = records.controllerOf(raw, this.name);
+    const ctrl = this.objects.controller(c.m_Controller, this.prefab.ids[0], this.animatorEntry.path);
+    if (!ctrl) return;
     this.animator = new Animator(ctrl, (b) => this._bind(b), `${this.name}:${ctrl.name}`);
     this.animator.enabled = false;
     this.animatorComponentEnabled = !!c.m_Enabled;
@@ -428,11 +427,10 @@ export class StoryEffects {
   constructor(ctx) {
     this.ctx = ctx;
     this.resourceParent = new Transform("ResourceParent");              // AdvEpisodeResourceLoader.ResourceParent
-    this.materials = new FxMaterials(ctx.gl || null, "");
+    this.materials = FxMaterials.fromObjects(ctx.gl || null, ctx.objects);
     this.byName = new Map();                                            // TargetName -> AdvParticleEffect
     this.list = [];                                                     // command effects, load order
     this.stageEffects = [];                                             // stage particle group effects
-    this.records = null;
     this._hooks = [];
     this.installed = false;
   }
@@ -472,16 +470,15 @@ export class StoryEffects {
 
   // AdvEpisodeResourceLoader.LoadParticleEffect for every Effect row (one instance per TargetName; IgnoreData rows are
   // not preloaded), Init(token) with speed 1
-  load(doc) {
-    this.records = new AnimRecords(doc, StoryCommandError);
+  load() {
     for (const c of this.ctx.episode.commands) {
       if (c.cmd !== "Effect" || c.IgnoreData || !(c.TargetName ?? "") || this.byName.has(c.TargetName)) continue;
-      const asset = doc.instances[c.TargetName];
-      if (!asset) continue;
-      const ex = doc.effects[asset];
-      if (!ex) throw new StoryCommandError(`effect ${asset} is not in the story data`);
-      const e = new AdvParticleEffect(c.TargetName, ex, { materials: this.materials, rng: effectParticleRandom(this.ctx),
-                                                          parent: this.resourceParent, records: this.records });
+      if (!c.TargetAssetName) continue;
+      const asset = this.ctx.data.asset(`Adv/Effect/${c.TargetAssetName}`);
+      if (asset.objects.length !== 1) throw new StoryCommandError(`${c.TargetAssetName}: expected one effect root`);
+      const prefab = Prefab.fromObjects(this.ctx.assets, asset.objects);
+      const e = new AdvParticleEffect(c.TargetName, prefab, { materials: this.materials, rng: effectParticleRandom(this.ctx),
+        parent: this.resourceParent, objects: this.ctx.objects });
       e.init(1);
       this.byName.set(c.TargetName, e);
       this.list.push(e);
@@ -525,10 +522,8 @@ export const storyEffects = (ctx) => featureSlot(ctx, "effects", () => new Story
 export const loadEffects = (ctx) => {
   const uses = ctx.episode.commands.some((c) => c.cmd === "Effect" && !c.IgnoreData);
   if (!uses) return null;
-  const file = ctx.story && ctx.story.effects;
-  if (!file) throw new StoryCommandError("the story data has no effects.json");
   const fx = storyEffects(ctx);
-  fx.load(ctx.assets.json(file));
+  fx.load();
   const s = featureState(ctx);
   (s.speedListeners = s.speedListeners || []).push((rate) => fx.setPlaybackSpeed(rate));
   return fx;
@@ -537,20 +532,20 @@ export const loadEffects = (ctx) => {
 // AdvStage particle groups (AdvParticleEffectGroupCollection._groups[i]._particleEffects): one AdvParticleEffect per
 // referenced component over the stage prefab's subtree, Init(token) at stage load (stopped, cleared, hidden), then
 // updated and drawn with the command effects (their random stream). prefab: the stage's engine/prefab.js Prefab;
-// records: AnimRecords of the scene data file. Returns the groups (arrays of effects): AdvStage.PlayParticleEffects(i) =
+// objects: the shared ObjectResources. Returns the groups (arrays of effects): AdvStage.PlayParticleEffects(i) =
 // each play(), StopParticleEffects(i) = each stop(false, ctx.loop), SetPlaybackSpeed(r) = each setPlaybackSpeed(r) over
 // all groups.
-export const createStageParticleGroups = (ctx, stageName, prefab, collection, records) => {
+export const createStageParticleGroups = (ctx, stageName, prefab, collection, objects) => {
   const fx = storyEffects(ctx), rng = effectParticleRandom(ctx);
   const byPath = new Map();                     // a component referenced by several groups is one effect
   const groups = collection._groups.map((g, gi) => g._particleEffects.map((ref, k) => {
-    if (!ref || ref.class !== "AdvParticleEffect" || typeof ref.gameObject !== "string")
+    const path = prefab.pathOf(ref);
+    if (!path || !prefab.components(path, "AdvParticleEffect").length)
       throw new StoryCommandError(`stage ${stageName}: particle group ${gi} entry ${k} is not an AdvParticleEffect`);
-    let e = byPath.get(ref.gameObject);
+    let e = byPath.get(path);
     if (!e) {
-      e = new AdvParticleEffect(`${stageName}:${ref.gameObject}`, null, { materials: fx.materials, rng, records, prefab,
-                                                                          rootPath: ref.gameObject });
-      byPath.set(ref.gameObject, e);
+      e = new AdvParticleEffect(`${stageName}:${path}`, prefab, { materials: fx.materials, rng, objects, rootPath: path });
+      byPath.set(path, e);
     }
     return e;
   }));
diff --git a/src/story/features/frame.js b/src/story/features/frame.js
index e2137ed..8ad7ac2 100644
--- a/src/story/features/frame.js
+++ b/src/story/features/frame.js
@@ -4,7 +4,8 @@ import { TMPText } from "../../engine/uitext.js";
 import { StoryCommandError } from "../interfaces.js";
 import { StoryText } from "../ui-ruby.js";
 import { CanvasAnimator, CanvasNode, CanvasPrefab, bindCanvasProperty, compOf, compsOf } from "./canvas.js";
-import { AnimRecords } from "./clips.js";
+import { componentClass } from "../../engine/prefab.js";
+import { uiTextBinding } from "../ui-objects.js";
 import { DOFloat } from "./dotween.js";
 import { stretchView, storyScreen } from "./screen.js";
 import { featureSlot, featureState } from "./state.js";
@@ -139,10 +140,10 @@ const LANGUAGE_ENGLISH = 1;                            // Fwk.Localization.Langu
 // (LocalizeManager's emoji sprite asset for UIText.SetText) and the serialized text as TMP's own. A node without a
 // binding keeps no text component: a drawing session refuses row texts for it (checkTexts), and it raises when it
 // would draw a text.
-const bindFrameTexts = (ui, name, prefab, bindings) => {
+const bindFrameTexts = (ui, name, prefab) => {
   for (const n of prefab.nodes.values()) {
-    if (!n.tmp || !bindings[n.path]) continue;
-    const b = bindings[n.path], loc = compOf(n.rec, "LocalizeText");
+    if (!n.tmp) continue;
+    const b = uiTextBinding(n, ui.fonts), loc = compOf(n.rec, "LocalizeText");
     if (loc && loc.m_Enabled && loc._localizeEnabled && loc._masterTextID && loc._masterTextID !== "0")
       throw new UIError(`frame ${name}: ${n.path}: a localized serialized text (LocalizeText) not implemented`);
     if (b.localizeKoreanAdjust && b.localizeKoreanAdjust.m_Enabled)
@@ -159,10 +160,11 @@ const bindFrameTexts = (ui, name, prefab, bindings) => {
 
 // AdvFrame
 export class FrameInstance {
-  constructor(view, name, doc) {
+  constructor(view, name, id) {
+    const doc = view.ctx.assets.prefab(id);
     const screen = view.screen, canvas = screen.canvas.frame;
     this.view = view; this.name = name; this.screen = screen;
-    const prefab = this.prefab = new CanvasPrefab(doc.nodes, null, canvas);
+    const prefab = this.prefab = new CanvasPrefab(doc.nodes, null, canvas, id);
     const rootRec = doc.nodes[0], comp = compOf(rootRec, "AdvFrame");
     if (!comp) throw new UIError(`frame ${name}: no AdvFrame`);
     this.root = prefab.root;
@@ -170,7 +172,7 @@ export class FrameInstance {
     if (!this.group || !this.group.canvasGroup) throw new UIError(`frame ${name}: no CanvasGroup`);
     if (comp._screenPadding) throw new UIError(`frame ${name}: AdvFrameScreenPadding not implemented`);
     // Coffee UIParticle and the particle systems of the prefab (uiparticle.js)
-    const hasParticles = doc.nodes.some((r) => (r.components || []).some((c) => ["UIParticle", "ParticleSystem"].includes(c.class || c.type)));
+    const hasParticles = doc.nodes.some((r) => (r.components || []).some((c) => ["UIParticle", "ParticleSystem"].includes(componentClass(c))));
     this.particles = hasParticles ? new PrefabParticles(screen.canvasParticles("frame"), prefab, doc.nodes, name) : null;
     // Animators of the prefab (the AdvFrame's own one drives the states)
     this.animators = [];
@@ -178,10 +180,10 @@ export class FrameInstance {
       for (const a of compsOf(rec, "Animator")) {
         const node = prefab.node(rec.path);
         const an = new CanvasAnimator(node, a, (b) => bindCanvasProperty(node, b, (n, prop) => this._bindExtra(n, prop)),
-                                    `${name}:${rec.path}`, view.records);
+                                    `${name}:${rec.path}`, view.ctx.objects);
         this.animators.push(an);
         screen.animators.push(an);
-        if (comp._animator && comp._animator.gameObject === rec.path) this.animator = an;
+        if (comp._animator && prefab.source.pathOf(comp._animator) === rec.path) this.animator = an;
       }
     if (comp._animator && !this.animator) throw new UIError(`frame ${name}: Animator ${comp._animator.gameObject} missing`);
     // StretchPosition (MonoBehaviour Update: offsetMax.x = -(positionPercent / 100) x parent width)
@@ -204,7 +206,7 @@ export class FrameInstance {
     }
     // with the story UI's fonts the texts are laid out (and drawn) as the story UI lays out its own
     const ui = view.ctx.ui, fonts = ui && ui.fonts;
-    if (fonts && fonts.frameTexts && fonts.frameTexts[name]) bindFrameTexts(ui, name, prefab, fonts.frameTexts[name]);
+    if (fonts) bindFrameTexts(ui, name, prefab);
     this.init();
   }
 
@@ -345,15 +347,14 @@ export class FrameView {
   }
 
   // AdvEpisodeResourceLoader.LoadFrame for every Frame row (IgnoreData rows are not preloaded)
-  load(doc) {
-    this.records = new AnimRecords(doc, UIError);
+  load() {
     for (const c of this.ctx.episode.commands) {
       if (c.cmd !== "Frame" || c.IgnoreData) continue;
       const name = c.TargetAssetName ?? "";
       if (!name.trim() || this.frames.has(name)) continue;
-      const d = doc.frames[name];
-      if (!d) throw new StoryCommandError(`frame ${name} is not in the story data`);
-      this.frames.set(name, new FrameInstance(this, name, d));
+      const d = this.ctx.data.asset(`Adv/Frame/${name}`);
+      if (d.objects.length !== 1) throw new StoryCommandError(`frame ${name}: expected one prefab root`);
+      this.frames.set(name, new FrameInstance(this, name, d.objects[0]));
     }
     for (const f of this.frames.values()) f.checkTexts(this.ctx);
   }
@@ -374,12 +375,10 @@ export class FrameView {
 export const frameView = (ctx) => featureSlot(ctx, "frame", () => new FrameView(ctx));
 
 export const loadFrames = (ctx) => {
-  const file = ctx.story && ctx.story.frames;
   const uses = ctx.episode.commands.some((c) => c.cmd === "Frame" && !c.IgnoreData && (c.TargetAssetName ?? "").trim());
   if (!uses) return null;
-  if (!file) throw new StoryCommandError("the story data has no frames.json");
   const v = frameView(ctx);
-  v.load(ctx.assets.json(file));
+  v.load();
   const s = featureState(ctx);
   s.snapshots = s.snapshots || [];
   s.snapshots.push(() => ({ frames: v.snapshot() }));
diff --git a/src/story/features/posteffect.js b/src/story/features/posteffect.js
index 038f407..299faf6 100644
--- a/src/story/features/posteffect.js
+++ b/src/story/features/posteffect.js
@@ -69,18 +69,19 @@ export class ChildVolume {
 export const postEffects = (ctx) => featureSlot(ctx, "postEffect", () => ({ profiles: new Map(), children: new Map() }));
 
 export const loadPostEffects = async (ctx) => {
-  const pe = postEffects(ctx), file = ctx.story && ctx.story.postEffects;
-  if (!file) return pe;
-  const doc = ctx.assets.json(file);
-  for (const [name, profile] of Object.entries(doc.postEffects || {})) {
-    if (profile.asset !== "VolumeProfile") throw new StoryCommandError(`post effect ${name}: not a VolumeProfile`);
-    pe.profiles.set(name, profile);
+  const pe = postEffects(ctx);
+  for (const address of Object.keys(ctx.data?.parts?.assets || {})) {
+    if (!address.startsWith("Adv/PostEffect/")) continue;
+    const product = ctx.data.asset(address);
+    if (product.objects.length !== 1 || ctx.objects.mono(product.objects[0]).class !== "VolumeProfile")
+      throw new StoryCommandError(`post effect ${address}: not a VolumeProfile`);
+    pe.profiles.set(address.slice("Adv/PostEffect/".length), ctx.objects.profile(product.objects[0]));
   }
   const s = featureState(ctx);
   s.disposers.push(() => { for (const c of pe.children.values()) c.refresh(); pe.children.clear(); });
   s.snapshots = s.snapshots || [];
   s.snapshots.push(() => ({ postEffect: [...pe.children.values()].map((c) => [c.name, c.volume.enabled, c.volume.weight]) }));
-  if (ctx.renderer) await ctx.renderer.post.loadVolumeTextures("", [...pe.profiles.values()], ctx.assets);
+  if (ctx.renderer) await ctx.renderer.post.loadVolumeTextures([...pe.profiles.values()], ctx.objects);
   return pe;
 };
 
diff --git a/src/story/features/screen.js b/src/story/features/screen.js
index c2d915a..f901d36 100644
--- a/src/story/features/screen.js
+++ b/src/story/features/screen.js
@@ -1,11 +1,10 @@
-import { F, join } from "../../engine/core.js";
+import { F } from "../../engine/core.js";
 import { mat4 } from "../../engine/math.js";
 import { URPPost } from "../../engine/postfx.js";
 import { ADV_CANVAS_LAYER, StoryCommandError } from "../interfaces.js";
 import { GLTarget, GLTex } from "../../engine/texture.js";
-import { ShaderLib } from "../../engine/glsl.js";
 import { UIDraw, UIMesh, uiColor32 } from "../../engine/ugui.js";
-import { CanvasGL, CanvasNode, ScreenCanvas } from "./canvas.js";
+import { CanvasGL, CanvasNode, ScreenCanvas, compOf } from "./canvas.js";
 import { DOTargets } from "./dotween.js";
 import { featureSlot, featureState } from "./state.js";
 import { CanvasParticles } from "./uiparticle.js";
@@ -25,7 +24,7 @@ import { CanvasParticles } from "./uiparticle.js";
 // mask to 0 (component defaults only).
 // ENGINE: with HDR and post-process alpha output allowed URP picks R16G16B16A16_SFloat for the colour target; UI
 // shaders write no depth, so depth of field and motion blur read the cleared depth.
-// The canvases, scalers, views, camera and screen image are ui/ui.json records (the story UI data).
+// The canvases, scalers, views, camera and screen image are story.ui records (the story UI data).
 
 export const SCREEN_CANVAS = Object.freeze({ video: 301, still: 302, frame: 303 });
 export const SCREEN_CANVAS_PATH = Object.freeze({ video: "UIAdvWidget/VideoCanvas", still: "UIAdvWidget/StillCanvas",
@@ -39,12 +38,10 @@ export const stretchView = (parent, name) => new CanvasNode({
   rect: { m_AnchorMin: { x: 0, y: 0 }, m_AnchorMax: { x: 1, y: 1 }, m_AnchoredPosition: { x: 0, y: 0 },
           m_SizeDelta: { x: 0, y: 0 }, m_Pivot: { x: 0.5, y: 0.5 } } }, parent);
 
-// the story UI data (ui/ui.json) and its directory
+// the story UI data (story.ui) and its directory
 export const storyUIDoc = (ctx) => featureSlot(ctx, "uiDoc", () => {
-  const file = ctx.story && ctx.story.ui;
-  if (!file) throw new StoryCommandError("the story data has no story UI (ui/ui.json)");
-  const cut = file.lastIndexOf("/");
-  return { doc: ctx.assets.json(file), dir: cut < 0 ? "" : file.slice(0, cut) };
+  const id = ctx.data.ui.widget;
+  return { doc: ctx.assets.prefab(id), prefab: ctx.objects.prefab(id) };
 });
 
 export const uiNode = (doc, path) => {
@@ -55,48 +52,27 @@ export const uiNode = (doc, path) => {
 
 // A screen canvas of the story UI data: a Screen Space - Camera canvas with the expected paint order and a CanvasScaler
 // (ScaleWithScreenSize) or Fwk.UI.ClampedCanvasScaler (the scale clamped past _maxAspectThreshold).
-export const screenCanvasSettings = (doc, path, sortingOrder) => {
-  const rec = uiNode(doc, path), c = rec.canvas, s = rec.canvasScaler;
+export const screenCanvasSettings = (doc, path, sortingOrder, prefab, objects) => {
+  const rec = uiNode(doc, path), c = compOf(rec, "Canvas");
+  const clamped = compOf(rec, "ClampedCanvasScaler"), s = clamped || compOf(rec, "CanvasScaler");
   if (!c || !s) throw new StoryCommandError(`${path}: no canvas or canvas scaler in the story UI data`);
   if (!c.m_Enabled || c.m_RenderMode !== 1 || c.m_SortingOrder !== sortingOrder || c.m_OverrideSorting || c.m_PixelPerfect)
     throw new StoryCommandError(`${path}: canvas (render mode ${c.m_RenderMode}, sorting order ${c.m_SortingOrder}) is not the expected camera canvas`);
   if (!s.m_Enabled || s.m_UiScaleMode !== 1) throw new StoryCommandError(`${path}: canvas scaler mode ${s.m_UiScaleMode} not implemented`);
   const scaler = { m_UiScaleMode: 1, m_ReferenceResolution: { ...s.m_ReferenceResolution }, m_ScreenMatchMode: s.m_ScreenMatchMode,
                    m_MatchWidthOrHeight: s.m_MatchWidthOrHeight, m_ReferencePixelsPerUnit: s.m_ReferencePixelsPerUnit };
-  if (s.class === "ClampedCanvasScaler") scaler._maxAspectThreshold = s._maxAspectThreshold;
-  return { sortingOrder, scaler, camera: c.camera || null, planeDistance: c.m_PlaneDistance ?? null };
+  if (clamped) scaler._maxAspectThreshold = s._maxAspectThreshold;
+  return { sortingOrder, scaler, camera: !c.m_Camera ? null : c.m_Camera.$ref ? objects.assets.contained(c.m_Camera).path : prefab.pathOf(c.m_Camera), planeDistance: c.m_PlaneDistance ?? null };
 };
 
 // the ADV viewport before the first draw (a headless session never draws): 13:6
 export const REFERENCE_VIEWPORT = Object.freeze({ width: 2340, height: 1080 });
 
-// The shaders of the screen canvases, packed in two places: the story's shaders/ (the frame, still and effect
-// materials) and the story UI's (UI/Default, which every image without a material and the video masks use). A shader
-// is read from the pack that has it.
-class ShaderPacks {
-  constructor(libs) { this.libs = libs; }
-  _lib(name) {
-    const l = this.libs.find((x) => x.index.has(name));
-    if (!l) throw new StoryCommandError(`shader not packed: ${name}`);
-    return l;
-  }
-  info(name) { return this._lib(name).info(name); }
-  defaults(name, ...a) { return this._lib(name).defaults(name, ...a); }
-  program(name, ...a) { return this._lib(name).program(name, ...a); }
-  state(name, ...a) { return this._lib(name).state(name, ...a); }
-}
-
-const uiShaderBase = (doc, dir) => {
-  const index = doc.shaders && doc.shaders.index;
-  if (!index || !/\/shaders\.json$/.test(index)) throw new StoryCommandError("the story UI data has no shader index");
-  return join(dir, index.replace(/\/shaders\.json$/, ""));
-};
-
 // UIAdvWidget._videoAndStillCamera as far as the canvases use it
-const stillCamera = (doc) => {
-  const cam = doc.videoAndStillCamera;
-  if (!cam || !cam.camera) throw new StoryCommandError("the story UI data has no video and still camera");
-  const c = cam.camera;
+const stillCamera = (prefab) => {
+  const widget = prefab.find("UIAdvWidget").c.fields;
+  const path = prefab.pathOf(widget._videoAndStillCamera), c = prefab.fields(path, "Camera");
+  const cam = { path, camera: c, additionalCameraData: prefab.fields(path, "UniversalAdditionalCameraData") };
   if (!c.m_Enabled || c.m_ClearFlags !== 2) throw new StoryCommandError(`video and still camera: clear flags ${c.m_ClearFlags} not implemented`);
   const r = c.m_NormalizedViewPortRect;
   if (r.x !== 0 || r.y !== 0 || r.width !== 1 || r.height !== 1) throw new StoryCommandError("video and still camera: viewport rect not implemented");
@@ -120,11 +96,11 @@ const ADV_VOLUME_LAYER_MASK = 1 << 11;
 export class StoryScreen {
   constructor(ctx) {
     this.ctx = ctx;
-    const { doc, dir } = storyUIDoc(ctx);
-    this.ui = doc; this.uiDir = dir;
-    this.camera = stillCamera(doc);
+    const { doc, prefab } = storyUIDoc(ctx);
+    this.ui = doc;
+    this.camera = stillCamera(prefab);
     this.canvases = Object.entries(SCREEN_CANVAS).map(([k, order]) => {
-      const st = screenCanvasSettings(doc, SCREEN_CANVAS_PATH[k], order), c = new ScreenCanvas(SCREEN_CANVAS_PATH[k], st);
+      const st = screenCanvasSettings(doc, SCREEN_CANVAS_PATH[k], order, prefab, ctx.objects), c = new ScreenCanvas(SCREEN_CANVAS_PATH[k], st, ctx.objects);
       if (k !== "frame") {
         if (st.camera !== this.camera.path) throw new StoryCommandError(`${c.name}: camera ${st.camera} is not the video and still camera`);
         c.perspective = { fov: this.camera.camera["field of view"] };
@@ -134,15 +110,17 @@ export class StoryScreen {
     });
     this.canvas = Object.fromEntries(this.canvases);
     // the screen image: a stretched RawImage under a canvas without an active scaler
-    const imgRec = uiNode(doc, doc.videoAndStillScreenImage), canvasRec = uiNode(doc, SCREEN_IMAGE_CANVAS);
-    if (!imgRec.rawImage || !imgRec.path.startsWith(`${SCREEN_IMAGE_CANVAS}/`) || imgRec.path.split("/").length !== 3)
+    const widget = prefab.find("UIAdvWidget").c.fields;
+    const imgRec = uiNode(doc, prefab.pathOf(widget._videoAndStillScreenImage)), canvasRec = uiNode(doc, SCREEN_IMAGE_CANVAS);
+    const rawImage = compOf(imgRec, "RawImage"), scaler = compOf(canvasRec, "CanvasScaler");
+    if (!rawImage || !imgRec.path.startsWith(`${SCREEN_IMAGE_CANVAS}/`) || imgRec.path.split("/").length !== 3)
       throw new StoryCommandError("the video and still screen image is not a RawImage of its canvas");
-    if (canvasRec.canvas.m_SortingOrder !== SCREEN_CANVAS.still || (canvasRec.canvasScaler && canvasRec.canvasScaler.m_Enabled))
+    if (compOf(canvasRec, "Canvas").m_SortingOrder !== SCREEN_CANVAS.still || (scaler && scaler.m_Enabled))
       throw new StoryCommandError(`${SCREEN_IMAGE_CANVAS}: canvas settings not implemented`);
-    this.screenCanvas = new ScreenCanvas(SCREEN_IMAGE_CANVAS, { sortingOrder: SCREEN_CANVAS.still, scaler: null });
+    this.screenCanvas = new ScreenCanvas(SCREEN_IMAGE_CANVAS, { sortingOrder: SCREEN_CANVAS.still, scaler: null }, ctx.objects);
     this.screenImage = new CanvasNode(imgRec, this.screenCanvas.root);
-    this.screenImage.rawImage = { ...imgRec.rawImage };
-    if (this.screenImage.rawImage.material) throw new StoryCommandError("video and still screen image: material not implemented");
+    this.screenImage.rawImage = { ...rawImage };
+    if (this.screenImage.rawImage.m_Material) throw new StoryCommandError("video and still screen image: material not implemented");
     // UIAdvWidget.InitVideoSeekFreezeOverlay: "VideoSeekFreeze" on the screen image's parent with the screen image's
     // anchors, position, size and pivot (unrotated, unit scale), a RawImage without raycasts under a CanvasGroup at
     // alpha 0, last sibling, inactive
@@ -178,13 +156,11 @@ export class StoryScreen {
   async load() {
     const ctx = this.ctx;
     if (!ctx.gl) return;
-    const libs = [new ShaderLib(ctx.gl, "shaders", ctx.assets), new ShaderLib(ctx.gl, uiShaderBase(this.ui, this.uiDir), ctx.assets)];
-    const packs = new ShaderPacks(libs);
-    this.gl = new CanvasGL(ctx.gl, packs, ctx.assets, ctx.ui);          // the story UI draws the canvas texts
+    this.gl = new CanvasGL(ctx.gl, ctx.objects, ctx.ui);
     await this.gl.load(GLTex, this.canvases.map(([, c]) => c));
     const R = ctx.renderer;
     if (!R) throw new StoryCommandError("the video and still camera's post-processing needs the story renderer");
-    this.post = new URPPost(ctx.gl, packs);
+    this.post = new URPPost(ctx.gl, ctx.objects.lib);
     this.post.volumeTextures = R.post.volumeTextures;     // the textures of the volume profiles (loadPostEffects)
     this.post.initLut();                                  // its own colour curves and internal LUT
   }
@@ -233,7 +209,10 @@ export class StoryScreen {
   canvasParticles(kind) {
     if (kind !== "frame") throw new StoryCommandError(`${this.canvas[kind].name}: canvas particles not implemented`);
     if (!this.frameParticles) {
-      const cp = this.frameParticles = new CanvasParticles(this.ctx, this.canvas.frame, () => this.ui);
+      const cp = this.frameParticles = new CanvasParticles(this.ctx, this.canvas.frame, () => {
+        const manager = this.ctx.objects.prefab(this.ctx.data.ui.uiManager);
+        return manager.find("Camera").c.fields;
+      });
       this.itemSources.push((n, a) => cp.itemsOf(n, a));
     }
     return this.frameParticles;
diff --git a/src/story/features/still.js b/src/story/features/still.js
index e9d368c..eb61f27 100644
--- a/src/story/features/still.js
+++ b/src/story/features/still.js
@@ -1,3 +1,4 @@
+import { componentClass } from "../../engine/prefab.js";
 import { F } from "../../engine/core.js";
 import { UIError } from "../../engine/ugui.js";
 import { StoryCommandError } from "../interfaces.js";
@@ -22,7 +23,7 @@ import { featureSlot, featureState } from "./state.js";
 // tweens paused; Init's deactivation disables the DOTweenSequences (OnDisable: DOKill), which kills the paused tweens of
 // the animations their commands reference. Tweens of other animations stay paused until a callback plays them.
 //
-// AdvStillView (ui/ui.json record `stillView`): _overlay, _background (Awake: its alpha 0), _target. SetStill(s):
+// AdvStillView (story.ui record `stillView`): _overlay, _background (Awake: its alpha 0), _target. SetStill(s):
 // UIAdvWidget.SuppressStillPostEffect, reparented under _target as its last sibling, localPosition 0, ApplyContainedScale
 // (_target scale = min(view width / 1920, view height / 1080), also on every resize). FadeTo(a, d, isShow): hide ->
 // _background DOFade(0) (not awaited); show with a == 0 -> _background DOFade(1) (not awaited); _overlay DOFade(a)
@@ -41,9 +42,10 @@ const STILL_COMPONENTS = new Set(["RectTransform", "CanvasRenderer", "CanvasGrou
 
 // AdvStill with its prefab instance
 export class StillInstance {
-  constructor(view, name, doc) {
+  constructor(view, name, id) {
+    const doc = view.ctx.assets.prefab(id);
     this.view = view; this.name = name;
-    const prefab = this.prefab = new CanvasPrefab(doc.nodes, null, view.screen.canvas.still);
+    const prefab = this.prefab = new CanvasPrefab(doc.nodes, null, view.screen.canvas.still, id);
     this.root = prefab.root;
     const adv = compOf(doc.nodes[0], "AdvStill");
     if (!adv) throw new UIError(`still ${name}: no AdvStill on the root`);
@@ -53,17 +55,17 @@ export class StillInstance {
       node: (p) => prefab.node(p),
       go: (n) => { if (!gos.has(n)) gos.set(n, { gameObject: n.path }); return gos.get(n); },
       abs: (p) => abs.get(p) || [],
-      componentOf: (r) => byRef.get(`${r.gameObject}\u0000${r.class || r.component}`) || null,
+      componentOf: (r) => byRef.get(`${prefab.source.pathOf(r)}\u0000${r.class || r.component}`) || null,
     };
     this.animations = []; this.sequenceComponents = [];
     for (const rec of doc.nodes) {
       const node = prefab.node(rec.path), list = [];
       for (const c of rec.components || []) {
-        const cls = c.class || c.type;
+        const cls = componentClass(c);
         if (!STILL_COMPONENTS.has(cls)) throw new UIError(`still ${name}:${rec.path}: component ${cls} not implemented`);
         let a = null;
-        if (cls === "DOTweenAnimation") { a = new DOTweenAnimation(this.host, node, c); this.animations.push(a); }
-        else if (cls === "DOTweenSequence") { a = new DOTweenSequenceComponent(this.host, node, c); this.sequenceComponents.push(a); }
+        if (cls === "DOTweenAnimation") { a = new DOTweenAnimation(this.host, node, c.fields); this.animations.push(a); }
+        else if (cls === "DOTweenSequence") { a = new DOTweenSequenceComponent(this.host, node, c.fields); this.sequenceComponents.push(a); }
         if (!a) continue;
         list.push(a);
         byRef.set(`${rec.path}\u0000${cls}`, a);
@@ -170,7 +172,7 @@ export class StillView {
     this.ctx = ctx;
     this.screen = storyScreen(ctx);
     this.mgr = storyDOTween(ctx);
-    const { doc, dir } = storyUIDoc(ctx), canvas = this.screen.canvas.still, base = SCREEN_CANVAS_PATH.still;
+    const { doc, prefab } = storyUIDoc(ctx), canvas = this.screen.canvas.still, base = SCREEN_CANVAS_PATH.still;
     const nodes = new Map();
     for (const rec of doc.nodes) {
       if (!rec.path.startsWith(`${base}/`)) continue;
@@ -178,18 +180,19 @@ export class StillView {
       const parent = parentPath === base ? canvas.root : nodes.get(parentPath);
       if (!parent) throw new UIError(`${rec.path}: parent not in the story UI data`);
       const n = new CanvasNode(rec, parent);
-      if (rec.image) {
-        n.image = { ...rec.image, m_Enabled: !!rec.image.m_Enabled, m_Color: { ...rec.image.m_Color },
-                    spriteObj: canvas.uiSprite(doc, rec.image.sprite, dir), material: null };
-        if (rec.image.material) throw new UIError(`${rec.path}: image material not implemented`);
+      const image = compOf(rec, "Image");
+      if (image) {
+        n.image = { ...image, m_Enabled: !!image.m_Enabled, m_Color: { ...image.m_Color },
+          spriteObj: canvas.sprite(image.m_Sprite), material: canvas.material(image.m_Material) };
       }
-      if (rec.rawImage || rec.text || rec.animator) throw new UIError(`${rec.path}: component not implemented on the still canvas`);
+      if (compOf(rec, "RawImage") || compOf(rec, "TextMeshProUGUI") || compOf(rec, "Animator"))
+        throw new UIError(`${rec.path}: component not implemented on the canvas`);
       nodes.set(rec.path, n);
     }
-    const viewRec = doc.nodes.find((r) => r.stillView);
+    const viewRec = doc.nodes.find((r) => compOf(r, "AdvStillView"));
     if (!viewRec || !nodes.has(viewRec.path)) throw new StoryCommandError("the story UI data has no AdvStillView");
-    const sv = viewRec.stillView, get = (p) => {
-      const n = nodes.get(p);
+    const sv = compOf(viewRec, "AdvStillView"), get = (p) => {
+      const n = nodes.get(typeof p === "string" ? p : prefab.pathOf(p));
       if (!n) throw new StoryCommandError(`AdvStillView: ${p} missing`);
       return n;
     };
@@ -224,14 +227,14 @@ export class StillView {
   }
 
   // AdvEpisodeResourceLoader.LoadStill for every Still row with a name (IgnoreData rows are not preloaded)
-  load(doc) {
+  load() {
     for (const c of this.ctx.episode.commands) {
       if (c.cmd !== "Still" || c.IgnoreData) continue;
       const name = c.TargetAssetName ?? "";
       if (!name.trim() || this.stills.has(name)) continue;
-      const d = doc.stills[name];
-      if (!d) throw new StoryCommandError(`still ${name} is not in the story data`);
-      const s = new StillInstance(this, name, d);
+      const d = this.ctx.data.asset(`Adv/Still/${name}`);
+      if (d.objects.length !== 1) throw new StoryCommandError(`still ${name}: expected one prefab root`);
+      const s = new StillInstance(this, name, d.objects[0]);
       this.stills.set(name, s);
       this.list.push(s);
     }
@@ -284,10 +287,8 @@ export const stillView = (ctx) => featureSlot(ctx, "still", () => new StillView(
 export const loadStills = (ctx) => {
   const uses = ctx.episode.commands.some((c) => c.cmd === "Still" && !c.IgnoreData && (c.TargetAssetName ?? "").trim());
   if (!uses) return null;
-  const file = ctx.story && ctx.story.stills;
-  if (!file) throw new StoryCommandError("the story data has no stills.json");
   const v = stillView(ctx);
-  v.load(ctx.assets.json(file));
+  v.load();
   const s = featureState(ctx);
   s.disposers.push(() => v.dispose());
   (s.snapshots = s.snapshots || []).push(() => ({ still: v.snapshot() }));
diff --git a/src/story/features/uiparticle.js b/src/story/features/uiparticle.js
index b8f0133..f3d877c 100644
--- a/src/story/features/uiparticle.js
+++ b/src/story/features/uiparticle.js
@@ -1,5 +1,6 @@
 import { F } from "../../engine/core.js";
-import { FxParticleSystem, FxV, PS_STOP } from "../../engine/particles.js";
+import { componentClass } from "../../engine/prefab.js";
+import { FxMaterials, FxParticleSystem, FxV, PS_STOP } from "../../engine/particles.js";
 import { UnityRandom } from "../../engine/random.js";
 import { UI_STRIDE } from "../../engine/ugui.js";
 import { StoryCommandError } from "../interfaces.js";
@@ -89,10 +90,9 @@ const lossyScale = (world, n) => {
 };
 
 // The UI camera of the story UI data (FrameCanvas' worldCamera at run time): orthographic size and clip planes
-export const uiCamera = (doc) => {
-  const rec = doc.uiCamera;
-  if (!rec || !rec.camera) throw new StoryCommandError("the story UI data has no UI camera (uiCamera): canvas particles are not drawn without it");
-  const c = rec.camera, size = c["orthographic size"], near = c["near clip plane"], far = c["far clip plane"];
+export const uiCamera = (c) => {
+  if (!c) throw new StoryCommandError("the story UI data has no UI camera: canvas particles are not drawn without it");
+  const size = c["orthographic size"], near = c["near clip plane"], far = c["far clip plane"];
   if (!c.orthographic) throw new StoryCommandError("UI camera: a perspective UI camera not implemented");
   if (!(size > 0) || !(far > near)) throw new StoryCommandError("UI camera: orthographic size or clip planes missing");
   return { size, near, far };
@@ -165,7 +165,7 @@ class UIParticleRenderer {
     this.isTrail = isTrail;
     this.material = entry.material;
     const t = this.material && (this.material.textures || {})[MAIN_TEX];
-    this.texture = t && t.texture ? t.texture.texture : null;
+    this.texture = t && t.texture ? t.texture.id : null;
     this.delay = true;
     this.mainEmitter = mainEmitter;
     this.enabled = true;
@@ -411,22 +411,22 @@ class UIParticle {
 export class PrefabParticles {
   constructor(host, prefab, nodes, name) {
     this.host = host; this.prefab = prefab; this.name = name;
-    const rng = particleRandom(host.ctx);
+    const rng = particleRandom(host.ctx), materials = FxMaterials.fromObjects(null, host.ctx.objects);
     this.entries = []; this.byPath = new Map(); this.uiParticles = []; this.activity = [];
     for (const rec of nodes) {
       const node = prefab.node(rec.path);
       for (const c of rec.components || []) {
-        const k = c.class || c.type;
+        const k = componentClass(c);
         if (k === "UIParticle") {
-          const u = new UIParticle(this, node, c);
+          const u = new UIParticle(this, node, c.fields);
           this.uiParticles.push(u);
           node.uiParticle = u;
           this.activity.push({ node, uip: u, on: false });
         } else if (k === "ParticleSystem") {
           const r = compOf(rec, "ParticleSystemRenderer");
-          const system = new FxParticleSystem(c, r, new NodeTransform(host, node), { rng, materials: null, name: `${name}:${rec.path}` });
-          const e = { node, system, renderer: r, material: r && r.m_Materials && r.m_Materials[0] ? r.m_Materials[0] : null,
-                      trails: !!(c.TrailModule && c.TrailModule.enabled) };
+          const system = new FxParticleSystem(c.fields, r, new NodeTransform(host, node), { rng, materials, name: `${name}:${rec.path}` });
+          const e = { node, system, renderer: r, material: r?.m_Materials?.[0] ? host.canvas.material(r.m_Materials[0]) : null,
+                      trails: !!(c.fields.TrailModule && c.fields.TrailModule.enabled) };
           this.entries.push(e); this.byPath.set(rec.path, e);
           this.activity.push({ node, entry: e, on: false });
         }
@@ -438,7 +438,7 @@ export class PrefabParticles {
       return out;
     };
     for (const e of this.entries) e.system.children = below(e.node, []);
-    for (const e of this.entries) if (e.system.subEmitters.length) e.system.linkSubEmitters((ref) => { const x = this.byPath.get(ref.gameObject); return x ? x.system : null; });
+    for (const e of this.entries) if (e.system.subEmitters.length) e.system.linkSubEmitters((ref) => { const x = this.byPath.get(prefab.ref(ref).path); return x ? x.system : null; });
     const covered = new Set(this.uiParticles.flatMap((u) => u.systems()));
     for (const e of this.entries) {
       if (covered.has(e)) {
@@ -448,7 +448,6 @@ export class PrefabParticles {
         if (e.material) {
           for (const [k, t] of Object.entries(e.material.textures || {}))
             if (k !== MAIN_TEX && t && t.texture) throw new StoryCommandError(`${e.node.path}: particle material texture ${k} not implemented`);
-          host.canvas.material(e.material);
         }
       } else if (e.renderer && e.renderer.m_Enabled && e.system.emission.enabled) {
         throw new StoryCommandError(`${e.node.path}: a drawing particle system outside a UIParticle not implemented`);
diff --git a/src/story/features/video.js b/src/story/features/video.js
index f1c3ad2..938709d 100644
--- a/src/story/features/video.js
+++ b/src/story/features/video.js
@@ -1,7 +1,7 @@
 import { F } from "../../engine/core.js";
 import { UIError } from "../../engine/ugui.js";
 import { StoryCommandError } from "../interfaces.js";
-import { CanvasNode } from "./canvas.js";
+import { CanvasNode, compOf } from "./canvas.js";
 import { DT_PLUGIN, dtTo, storyDOTween } from "./dotween-core.js";
 import { SCREEN_CANVAS_PATH, storyScreen, storyUIDoc } from "./screen.js";
 import { featureSlot, featureState } from "./state.js";
@@ -227,8 +227,8 @@ export class VideoTimeline {
 
 // the video system of a story context: queue, current video, view, timeline, flow flags
 export class StoryVideo {
-  constructor(ctx, doc) {
-    this.ctx = ctx; this.doc = doc;
+  constructor(ctx, data) {
+    this.ctx = ctx; this.data = data;
     this.requests = [];                       // _videoRequestQueue
     for (const c of ctx.episode.commands)
       if ((c.cmd === "Movie" || c.cmd === "Clip") && !c.IgnoreData && (c.VideoID || 0) > 0) this.requests.push(c.VideoID);
@@ -265,7 +265,7 @@ export class StoryVideo {
   // EnqueueVideoLoadTask -> PrepareVideoTask
   _enqueue() {
     if (!this.requests.length || this.tasks.length >= MAX_VIDEO_LOAD_TASK) return false;
-    const id = this.requests.shift(), rec = this.doc.videos[id];
+    const id = this.requests.shift(), rec = this.data.videoFor(id);
     if (!rec) throw new StoryCommandError(`video ${id} is not in the story data`);
     let v = null;
     if (rec.master && (rec.master._assetName ?? "").trim()) {
@@ -365,13 +365,13 @@ export class StoryVideo {
   }
 }
 
-// AdvVideoView (ui/ui.json record `videoView`) on VideoCanvas
+// AdvVideoView (story.ui record `videoView`) on VideoCanvas
 export class VideoView {
   constructor(ctx) {
     this.ctx = ctx;
     this.screen = storyScreen(ctx);
     this.mgr = storyDOTween(ctx);
-    const { doc, dir } = storyUIDoc(ctx), canvas = this.screen.canvas.video, base = SCREEN_CANVAS_PATH.video;
+    const { doc, prefab } = storyUIDoc(ctx), canvas = this.screen.canvas.video, base = SCREEN_CANVAS_PATH.video;
     const nodes = new Map();
     for (const rec of doc.nodes) {
       if (!rec.path.startsWith(`${base}/`)) continue;
@@ -379,19 +379,19 @@ export class VideoView {
       const parent = parentPath === base ? canvas.root : nodes.get(parentPath);
       if (!parent) throw new UIError(`${rec.path}: parent not in the story UI data`);
       const n = new CanvasNode(rec, parent);
-      if (rec.image) {
-        const mat = rec.image.material ? doc.materials[rec.image.material] : null;
-        if (rec.image.material && !mat) throw new UIError(`${rec.path}: material ${rec.image.material} not in the story UI data`);
-        n.image = { ...rec.image, m_Enabled: !!rec.image.m_Enabled, m_Color: { ...rec.image.m_Color },
-                    spriteObj: canvas.uiSprite(doc, rec.image.sprite, dir), material: mat ? canvas.material(mat) : null };
+      const image = compOf(rec, "Image");
+      if (image) {
+        n.image = { ...image, m_Enabled: !!image.m_Enabled, m_Color: { ...image.m_Color },
+          spriteObj: canvas.sprite(image.m_Sprite), material: canvas.material(image.m_Material) };
       }
-      if (rec.rawImage || rec.text || rec.animator) throw new UIError(`${rec.path}: component not implemented on the video canvas`);
+      if (compOf(rec, "RawImage") || compOf(rec, "TextMeshProUGUI") || compOf(rec, "Animator"))
+        throw new UIError(`${rec.path}: component not implemented on the canvas`);
       nodes.set(rec.path, n);
     }
-    const viewRec = doc.nodes.find((r) => r.videoView);
+    const viewRec = doc.nodes.find((r) => compOf(r, "AdvVideoView"));
     if (!viewRec || !nodes.has(viewRec.path)) throw new StoryCommandError("the story UI data has no AdvVideoView");
-    const vv = viewRec.videoView, get = (p) => {
-      const n = nodes.get(p);
+    const vv = compOf(viewRec, "AdvVideoView"), get = (p) => {
+      const n = nodes.get(typeof p === "string" ? p : prefab.pathOf(p));
       if (!n) throw new StoryCommandError(`AdvVideoView: ${p} missing`);
       return n;
     };
@@ -535,8 +535,7 @@ const runSeekRespeedLoop = async (v, p) => {
 export const loadVideos = (ctx) => {
   const uses = ctx.episode.commands.some((c) => (c.cmd === "Movie" || c.cmd === "Clip") && !c.IgnoreData);
   if (!uses) return null;
-  const file = ctx.story && ctx.story.videos;
-  const v = featureSlot(ctx, "video", () => new StoryVideo(ctx, file ? ctx.assets.json(file) : { videos: {} }));
+  const v = featureSlot(ctx, "video", () => new StoryVideo(ctx, ctx.data));
   const s = featureState(ctx);
   s.disposers.push(() => v.dispose());
   (s.snapshots = s.snapshots || []).push(() => ({ video: v.snapshot() }));
diff --git a/src/story/field.js b/src/story/field.js
index de4dc0c..eff35ad 100644
--- a/src/story/field.js
+++ b/src/story/field.js
@@ -1,6 +1,5 @@
 import { F } from "../engine/core.js";
 import { URPPost } from "../engine/postfx.js";
-import { Prefab } from "../engine/prefab.js";
 import { Transform, mat4 } from "../engine/math.js";
 import { EASE } from "../engine/tween.js";
 
@@ -46,8 +45,7 @@ export const advScreenSize = (width, height, level) => {
 
 // Fwk.Cam.UniversalCamera behind CameraManager.MainCamera
 export class AdvCamera {
-  constructor(loop, cameraNode) {
-    const cam = cameraNode.components.find((c) => c.type === "Camera");
+  constructor(loop, cam) {
     this.loop = loop;
     this.near = cam["near clip plane"];
     this.far = cam["far clip plane"];
@@ -126,11 +124,11 @@ export class AdvCamera {
 export class AdvCharacterField {
   constructor(loop, prefab, parent) {
     this.loop = loop;
-    this.prefab = new Prefab(prefab);
+    this.prefab = prefab;
     this.root = this.prefab.root;
     this.root.setParent(parent);
-    const c = this.prefab.component(this.root.name, "AdvCharacterField");
-    const tf = (ref) => this.prefab.transform(ref.transform);
+    const c = this.prefab.fields(this.root.name, "AdvCharacterField");
+    const tf = (ref) => this.prefab.transformOf(ref);
     this.field = tf(c._field);
     this.stages = c._characterStages.map(tf);
     this.anchors = c._focusAnchors.map(tf);
@@ -233,18 +231,18 @@ export class AdvCharacterField {
 // AdvBackgroundField
 export class AdvBackgroundField {
   constructor(prefab, parent) {
-    this.prefab = new Prefab(prefab);
+    this.prefab = prefab;
     this.root = this.prefab.root;
     this.root.setParent(parent);
-    const c = this.prefab.component(this.root.name, "AdvBackgroundField");
-    this.field = this.prefab.transform(c._field.transform);
-    const srPath = c._renderer.gameObject;
+    const c = this.prefab.fields(this.root.name, "AdvBackgroundField");
+    this.field = this.prefab.transformOf(c._field);
+    const srPath = this.prefab.pathOf(c._renderer);
     this.spriteTransform = this.prefab.transform(srPath);
-    this.spriteRenderer = this.prefab.component(srPath, "SpriteRenderer");
-    const planePath = `${c._field.transform}/BaseRenderer`;
+    this.spriteRenderer = this.prefab.fields(srPath, "SpriteRenderer");
+    const planePath = `${this.prefab.pathOf(c._field)}/BaseRenderer`;
     this.planeTransform = this.prefab.transform(planePath);
-    this.planeRenderer = this.prefab.component(planePath, "MeshRenderer");
-    this.planeMesh = this.prefab.component(planePath, "MeshFilter").m_Mesh;
+    this.planeRenderer = this.prefab.fields(planePath, "MeshRenderer");
+    this.planeMesh = this.prefab.fields(planePath, "MeshFilter").m_Mesh;
     this.active = false;
     this.sprite = null;
     this.color = { r: 1, g: 1, b: 1, a: 1 };                 // the SpriteRenderer's colour
@@ -278,14 +276,14 @@ export class AdvBackgroundField {
 
 // AdvGlobalVolume + the main camera's volume stack
 export class AdvGlobalVolume {
-  constructor(prefab, quality) {
-    this.prefab = new Prefab(prefab);
+  constructor(prefab, quality, objects) {
+    this.prefab = prefab;
     const root = this.prefab.root.name;
-    const c = this.prefab.component(root, "AdvGlobalVolume");
-    const vol = (path) => this.prefab.component(path, "Volume");
-    this.all = { volume: vol(c._allVolume.gameObject), profile: null, enabled: false, weight: 1 };
-    const wu = `${c._warmupObjects.gameObject}/VolumeAll`;
-    this.warmup = { volume: vol(wu), profile: vol(wu).sharedProfile, enabled: true, weight: vol(wu).weight };
+    const c = this.prefab.fields(root, "AdvGlobalVolume");
+    const vol = (path) => this.prefab.fields(path, "Volume");
+    this.all = { volume: vol(this.prefab.pathOf(c._allVolume)), profile: null, enabled: false, weight: 1 };
+    const wu = `${this.prefab.pathOf(c._warmupObjects)}/VolumeAll`;
+    this.warmup = { volume: vol(wu), profile: objects.profile(vol(wu).sharedProfile), enabled: true, weight: vol(wu).weight };
     this.quality = quality;
     // ENGINE: global volumes of equal priority blend in the volume manager's registration order (VolumeCollection:
     // Register appends, SortByPriority is a stable sort); a Volume registers in OnEnable and unregisters in OnDisable,
diff --git a/src/story/interfaces.js b/src/story/interfaces.js
index 8321d75..6d480cb 100644
--- a/src/story/interfaces.js
+++ b/src/story/interfaces.js
@@ -93,13 +93,13 @@ export const checkEpisodeCommands = (commands, what = "episode") => {
 //   gl             the WebGL2 context (null when headless)
 export const STORY_CONTEXT_FIELDS = Object.freeze(["loop", "camera", "field", "background", "fieldRenderer", "volume",
   "characters", "stages", "ui", "audio", "quality", "settings", "localize", "lang", "playbackMode", "titleTextId",
-  "episode", "story", "assets", "renderer", "gl"]);
+  "episode", "story", "assets", "renderer", "gl", "data", "objects"]);
 
 export const createStoryContext = (parts) => {
-  const ctx = {};
+  const ctx = {}, values = { data: null, objects: null, ...parts };
   for (const k of STORY_CONTEXT_FIELDS) {
-    if (!(k in parts)) throw new TypeError(`StoryContext: "${k}" missing`);
-    ctx[k] = parts[k];
+    if (!(k in values)) throw new TypeError(`StoryContext: "${k}" missing`);
+    ctx[k] = values[k];
   }
   for (const k of Object.keys(parts))
     if (!STORY_CONTEXT_FIELDS.includes(k)) throw new TypeError(`StoryContext: unknown field "${k}"`);
diff --git a/src/story/models.js b/src/story/models.js
index d7a1045..9631a33 100644
--- a/src/story/models.js
+++ b/src/story/models.js
@@ -1,17 +1,14 @@
 import { ShaderLib } from "../engine/glsl.js";
 import { modelIndex } from "../live2d/model.js";
 
-// The models of a story's Character rows. story.json `models` maps a model address (Character/Live2D/<group>/<name>/
-// model/<name>) to a model id: the store holds the model's model.json under live2d/<id>/ and its objects in the
-// store's object table (loadStoryStore). Returns model(address) -> {id, model (its model.json, model.js modelIndex),
-// lib (the ShaderLib of its shaders: one per model id; null without gl)}; `what` names the story in errors.
-export const storyModels = (gl, store, story, what) => {
+// The model products of a story's Character rows, shared by product directory.
+export const storyModels = (gl, data) => {
+  const store = data.assets;
   const byId = new Map();
   return (address) => {
-    const id = story.models[address];
-    if (typeof id !== "string" || !id) throw new Error(`${what}: model ${address} is not in the story`);
+    const { dir: id } = data.model(address);
     if (!byId.has(id)) {
-      const model = modelIndex(store, `live2d/${id}`);
+      const model = modelIndex(store, id);
       byId.set(id, { id, model, lib: gl ? ShaderLib.fromObjects(gl, model.shaders, store) : null });
     }
     return byId.get(id);
diff --git a/src/story/player-core.js b/src/story/player-core.js
index a0426bb..a9d9436 100644
--- a/src/story/player-core.js
+++ b/src/story/player-core.js
@@ -224,7 +224,7 @@ export class StoryPlayerCore {
 
   focusDataSettings(key) {
     const e = this.ctx.settings.player._focusDataSettingsMap._list.find((x) => x.Key === key);
-    return e ? e.Value : null;
+    return e ? this.ctx.objects.mono(e.Value) : null;
   }
 
   defaultFocusDataSettings() { return this.focusDataSettings(this.ctx.settings.player._defaultFocusDataSettingsKey); }
diff --git a/src/story/player.js b/src/story/player.js
index 7288db0..a67a60d 100644
--- a/src/story/player.js
+++ b/src/story/player.js
@@ -110,6 +110,7 @@ export class StoryPlayer extends EventTarget {
     if (o.assets) this.store = o.assets;
     else {
       this._manifest = await fetchStoryManifest(o.src, { fetch: o.fetch, signal });
+      this._lang ||= this._manifest.manifest.language || (this.languages.includes("ja") ? "ja" : this.languages[0]);
       this._labels();
       this.store = await this._loadStore(this._lang, signal);
     }
@@ -188,7 +189,7 @@ export class StoryPlayer extends EventTarget {
   get paused() { return this._paused; }
   get ended() { return !!this.session && this.session.ended; }
   get lang() { return this._lang; }
-  get languages() { return this._manifest ? Object.keys(this._manifest.manifest.languages) : [this._lang].filter(Boolean); }
+  get languages() { return this._manifest ? Object.keys(this._manifest.story.parts.ui) : [this._lang].filter(Boolean); }
   get info() { return this.store ? this.store.info : null; }
   // while a seek within a clip runs, the position it goes to
   get video() {
@@ -255,6 +256,7 @@ export class StoryPlayer extends EventTarget {
   setVolume(category, v) {
     this._volumes[category] = Math.min(1, Math.max(0, Number(v) || 0));
     if (this.session) this.session.setVolume(category, this._volumes[category]);
+    this._sync();
   }
 
   // restarts the episode at line i with the game's shortcut (the rows before it run instantly)
@@ -320,6 +322,7 @@ export class StoryPlayer extends EventTarget {
     const line = Math.max(0, this._startLine || 0, this.line), playing = this.session && this.session.started;
     this._stopClipSeek();
     await this._replace(async () => { this.store = store; this._lang = lang; await this._startSession(line, playing); });
+    this._status("");
   }
 
   // replaces the session (fn starts the new one)
diff --git a/src/story/renderer.js b/src/story/renderer.js
index ada55e2..01ca951 100644
--- a/src/story/renderer.js
+++ b/src/story/renderer.js
@@ -22,8 +22,9 @@ const localToWorld = Transform.prototype.localToWorld;
 // session}; `lib`: the ShaderLib of the story's shaders (stage, post-processing); `assets`: the story's AssetStore.
 // Each character draws with its model's own shaders (addCharacter).
 export class StoryRenderer {
-  constructor(gl, lib, scene, quality, loop, { assets } = {}) {
+  constructor(gl, lib, scene, quality, loop, { assets, objects } = {}) {
     this.gl = gl; this.lib = lib; this.scene = scene; this.quality = quality; this.loop = loop; this.assets = assets;
+    this.objects = objects;
     if (!gl.getExtension("EXT_color_buffer_float")) throw new Error("EXT_color_buffer_float is required");
     gl.frontFace(gl.CW);                    // Unity's front-face convention with its world-to-camera matrix
     this.characters = [];                   // {ch: Live2DCharacter, gl: Live2DDrawing}
@@ -41,7 +42,7 @@ export class StoryRenderer {
   // (CreateAdvViewport never pillarboxes)
   grainOptions() { return { grain: this.grain, grainScale: this.grainScale, grainIntensity: this.filmGrain }; }
 
-  async load(base = "") {
+  async load() {
     const gl = this.gl;
     this.tex = {
       white: GLTex.solid(gl, [255, 255, 255, 255], "white"),
@@ -53,21 +54,21 @@ export class StoryRenderer {
     this.sprites = new Map();
     for (const st of this.scene.stageData.values()) {
       const sp = st.backgroundSprite;
-      if (!sp || this.sprites.has(sp.sprite)) continue;
+      if (!sp || this.sprites.has(sp.id)) continue;
       const pos = new Float32Array(sp.vertices.flat()), uv = new Float32Array(sp.uv.flat());
-      this.sprites.set(sp.sprite, { texture: await GLTex.load(gl, base, sp.texture, this.assets),
+      this.sprites.set(sp.id, { texture: await this.objects.texture(sp.texture.id),
                                     pos: this._buffer(pos), uv: this._buffer(uv),
                                     idx: this._buffer(new Uint16Array(sp.indices), gl.ELEMENT_ARRAY_BUFFER),
                                     count: sp.indices.length, bounds: StoryRenderer.bounds(sp.vertices) });
     }
     // background plane mesh (built-in "Plane")
-    const m = this.scene.background.planeMesh;
+    const m = this.objects.mesh(this.scene.background.planeMesh);
     if (m.submeshes.length !== 1) throw new Error("plane mesh submeshes");
     this.plane = { pos: this._buffer(new Float32Array(m.vertices.flat())), uv: this._buffer(new Float32Array(m.uv0.flat())),
                    idx: this._buffer(new Uint16Array(m.submeshes[0]), gl.ELEMENT_ARRAY_BUFFER),
                    count: m.submeshes[0].length, bounds: StoryRenderer.bounds(m.vertices) };
     // post textures: film grain by FilmGrain.type, neutral colour curves, internal LUT
-    this.grain = await URPPost.loadGrain(gl, this.scene.postTextures.filmGrainTex, (d) => GLTex.load(gl, base, d));
+    this.grain = await URPPost.loadGrain(gl, this.scene.postTextures.filmGrainTex, (id) => this.objects.texture(id));
     this.post.initLut();
     for (const c of this.characters) { c.gl.white = this.tex.white; await c.gl.loadTextures(); c.gl.prepare(); }
   }
@@ -287,7 +288,7 @@ export class StoryRenderer {
     items.push({ sortingOrder: bg.planeRenderer.m_SortingOrder ?? -100, dist: this._distance(bg.planeTransform, this.plane.bounds.center),
                  draw: (frame) => this._drawPlane(frame) });
     if (bg.sprite) {
-      const s = this.sprites.get(bg.sprite.sprite);
+      const s = this.sprites.get(bg.sprite.id);
       items.push({ sortingOrder: bg.spriteRenderer.m_SortingOrder, dist: this._distance(bg.spriteTransform, s.bounds.center),
                    draw: (frame) => this._drawSprite(frame, s) });
     }
@@ -346,7 +347,7 @@ export class StoryRenderer {
   }
 
   _drawPlane(frame) {
-    const bg = this.scene.background, mat = bg.planeRenderer.m_Materials[0], shader = mat.shader.shader;
+    const bg = this.scene.background, mat = this.objects.material(bg.planeRenderer.m_Materials[0]), shader = mat.shader;
     const prog = this.lib.program(shader, 0, mat.keywords);
     prog.apply([this._perObject(bg.planeTransform, 12), ...this._material(mat, shader), frame.globals]);
     applyState(this.gl, this.lib.state(shader, 0, mat.floats));
@@ -355,7 +356,7 @@ export class StoryRenderer {
   }
 
   _drawSprite(frame, s) {
-    const bg = this.scene.background, sr = bg.spriteRenderer, mat = sr.m_Materials[0], shader = mat.shader.shader;
+    const bg = this.scene.background, sr = bg.spriteRenderer, mat = this.objects.material(sr.m_Materials[0]), shader = mat.shader;
     const prog = this.lib.program(shader, 0, mat.keywords);
     const c = bg.color, rc = sr.m_Color;
     prog.apply([{ _MainTex: s.texture, unity_SpriteColor: [rc.r * c.r, rc.g * c.g, rc.b * c.b, rc.a * c.a],
diff --git a/src/story/scene.js b/src/story/scene.js
new file mode 100644
index 0000000..e4a884f
--- /dev/null
+++ b/src/story/scene.js
@@ -0,0 +1,32 @@
+import { Transform } from "../engine/math.js";
+import { AdvBackgroundField, AdvCamera, AdvCharacterField, AdvFieldRendererManager, AdvGlobalVolume } from "./field.js";
+import { AdvStageData } from "./stage.js";
+
+// The story scene and stage assets, instantiated from their object references.
+export class StoryScene {
+  constructor(data, objects, loop, quality) {
+    const scene = data.scene, prefabs = scene.prefabs;
+    this.manager = new Transform("AdvManager");
+    const camera = objects.prefab(prefabs.cameraManager);
+    const manager = camera.fields(camera.root.name, "CameraManager");
+    const mainPath = camera.pathOf(manager._mainCamera);
+    this.camera = new AdvCamera(loop, camera.fields(mainPath, "Camera"));
+    this.field = new AdvCharacterField(loop, objects.prefab(prefabs.characterField), this.manager);
+    this.background = new AdvBackgroundField(objects.prefab(prefabs.backgroundField), this.manager);
+    this.volume = new AdvGlobalVolume(objects.prefab(prefabs.globalVolume), quality, objects);
+    this.fieldRenderer = new AdvFieldRendererManager(loop, quality);
+    this.stageData = new Map();
+    for (const key of Object.keys(data.parts.assets || {})) {
+      if (!key.startsWith("Adv/Stage/")) continue;
+      const address = key.slice("Adv/Stage/".length);
+      const asset = data.asset(key);
+      if (asset.objects.length !== 1) throw new Error(`${address}: expected one stage root`);
+      const stage = new AdvStageData(objects.prefab(asset.objects[0]), objects);
+      stage.prefab.root.setParent(this.manager);
+      this.stageData.set(address, stage);
+    }
+    const renderer = camera.fields(mainPath, "UniversalAdditionalCameraData").m_RendererIndex;
+    this.postTextures = { filmGrainTex: objects.grainTextures(scene.graphics.graphics, renderer) };
+    this.session = null;
+  }
+}
diff --git a/src/story/session.js b/src/story/session.js
index b801b46..5bb2d9b 100644
--- a/src/story/session.js
+++ b/src/story/session.js
@@ -1,14 +1,13 @@
 import { bindAssets, unbindAssets } from "../data/assets.js";
 import { Audio } from "../engine/audio.js";
-import { ShaderLib } from "../engine/glsl.js";
+import { ObjectResources } from "../engine/objects.js";
 import { trackGL } from "../engine/gltrack.js";
 import { PlayerLoop } from "../engine/loop.js";
-import { Transform } from "../engine/math.js";
 import { UnityRandom } from "../engine/random.js";
 import { Live2DCharacter } from "../live2d/character.js";
 import { cubismCore } from "../live2d/cubism.js";
 import { motionSyncCore } from "../live2d/motionsync.js";
-import { AdvBackgroundField, AdvCamera, AdvCharacterField, AdvFieldRendererManager, AdvGlobalVolume, AdvQuality } from "./field.js";
+import { AdvQuality } from "./field.js";
 import { ADV_PLAYBACK_MODE, STORY_FRAME_RATE, StoryCommandError, checkStoryUI, createStoryContext } from "./interfaces.js";
 import { storyModels } from "./models.js";
 import { StoryCharacters, StoryPlayerCore } from "./player-core.js";
@@ -17,10 +16,10 @@ import { speakerName } from "./commands/talk.js";
 import { StoryRenderer } from "./renderer.js";
 import { SilentAudio } from "./silent-audio.js";
 import { SimpleStorySession } from "./simple/session.js";
-import { AdvStageData } from "./stage.js";
+import { StoryData } from "./data.js";
+import { StoryScene } from "./scene.js";
 import { disposeStoryFeatures, installStoryFeatures, setStoryFeaturesSpeed } from "./features/index.js";
 import { StoryUI } from "./ui.js";
-import { AnimRecords } from "./features/clips.js";
 import { resumeCurrentVideoIfNeeded, seekStoryVideo, storyVideo, storyVideoPosition,
          tryPauseCurrentVideo } from "./features/video.js";
 
@@ -42,8 +41,6 @@ import { resumeCurrentVideoIfNeeded, seekStoryVideo, storyVideo, storyVideoPosit
 
 export { STORY_FRAME_RATE, STORY_LANGUAGES, advViewport, storyLines };
 
-const dirname = (p) => { const i = p.lastIndexOf("/"); return i < 0 ? "" : p.slice(0, i); };
-
 // every text the episode can show: the Talk lines and their speaker names, the Location captions, the title
 export const storyTexts = (episode, player, masterIds, localize, titleTextId = 0) => {
   const p = { ctx: { settings: { player, masterIds }, localize } }, out = new Set();
@@ -107,27 +104,25 @@ export class StorySession {
   // the facts a page can check before creating a session: the commands the episode executes, and the unsupported ones
   static requirements(store) {
     if (SimpleStorySession.isSimpleStory(store)) return SimpleStorySession.requirements(store);
-    const story = store.json("story.json"), episode = store.json(story.episode), scene = store.json(story.scene);
-    const commands = StoryPlayerCore.requiredCommands(episode, scene.settings.playerSettings);
+    const data = new StoryData(store);
+    const commands = StoryPlayerCore.requiredCommands(data.episode, data.playerSettings);
     return { commands, unsupported: commands.filter((c) => !StoryPlayerCore.supportedCommands().includes(c)) };
   }
 
   async _load(gl, store, opts) {
     if (!store) throw new Error("StorySession: an AssetStore is required");
     this.gl = gl || null; this.assets = store; this.opts = opts;
-    const story = this.story = store.json("story.json");
-    const episode = this.episode = store.json(story.episode);
-    const scene = store.json(story.scene);
-    const P = scene.settings.playerSettings;
+    const data = this.data = new StoryData(store);
+    const story = this.story = data.story, episode = this.episode = data.episode;
+    const P = data.playerSettings;
     const what = `story ${episode.advId ?? story.advId}`;
     const mode = episode.master ? episode.master._playbackMode || 0 : 0;
     StoryPlayerCore.checkEpisode(episode, P, what);
     this.playbackMode = mode;
-    const langDoc = store.has("ui/languages.json") ? store.json("ui/languages.json") : null;
-    const info = store.info || {};
-    const lang = this.lang = opts.lang || info.loadedLanguage || info.language || (langDoc && langDoc.language) || "ja";
-    if (langDoc && langDoc.language !== lang) throw new Error(`${what}: the loaded language is ${langDoc.language}, not ${lang}`);
-    const field = langDoc ? langDoc.field : STORY_LANGUAGES[lang];
+    const langDoc = data.ui.language;
+    const lang = this.lang = opts.lang || data.language;
+    if (data.language !== lang) throw new Error(`${what}: the loaded language is ${data.language}, not ${lang}`);
+    const field = langDoc.field;
     if (!field) throw new Error(`${what}: unknown language ${lang}`);
     // LocalizeManager.GetLocalizedText over the episode's text table and the title
     const titleTextId = opts.title === false || !episode.master ? 0 : episode.master._titleTextId || 0;
@@ -147,26 +142,8 @@ export class StorySession {
     this.seed = opts.seed ?? (Date.now() >>> 0);
     const random = opts.random || new UnityRandom(this.seed);        // UnityEngine.Random: one state for all
 
-    // the scene objects under the AdvManager transform (identity)
-    const manager = new Transform("AdvManager");
-    const camNode = scene.cameraManager.nodes.find((n) => n.path === "CameraManager/MainCamera");
-    if (!camNode) throw new Error(`${what}: scene.json has no CameraManager/MainCamera`);
-    const sc = this.scene = {
-      camera: new AdvCamera(loop, camNode),
-      field: new AdvCharacterField(loop, scene.characterField, manager),
-      background: new AdvBackgroundField(scene.backgroundField, manager),
-      volume: new AdvGlobalVolume(scene.globalVolume, quality),
-      fieldRenderer: new AdvFieldRendererManager(loop, quality),
-      stageData: new Map(),
-      postTextures: scene.postTextures[scene.shaders.cameraRenderers[0]],
-      session: null,
-    };
-    for (const [name, prefab] of Object.entries(scene.stages)) {
-      const st = new AdvStageData(prefab);                            // refuses stage features not reproduced
-      st.prefab.root.setParent(manager);
-      sc.stageData.set(name, st);
-    }
-    AdvStageData.resolveShared([...sc.stageData.values()]);
+    const objects = this.objects = new ObjectResources(store, { ...data.resourceOptions(), gl });
+    const sc = this.scene = new StoryScene(data, objects, loop, quality);
 
     // per-frame hooks in Unity phase order, before the UI's own: AdvPlayer.OnUpdate runs the character controllers,
     // then UIAdvWidget.OnUpdate (the motion waits run on the playback's own UniTask loop: StoryPlayerCore.play)
@@ -182,9 +159,8 @@ export class StorySession {
     loop.on("postLate", () => sc.volume.postLateUpdate());
 
     // the UI; its talk windows and every text the episode shows are checked before the rest loads
-    const uiDoc = store.json(story.ui);
-    const fonts = store.has("ui/fonts.json") ? store.json("ui/fonts.json") : null;
-    const parts = { assets: store, dir: dirname(story.ui), lang, fonts, language: langDoc };
+    const uiDoc = data.ui;
+    const parts = { assets: store, data, objects, dir: data.fontDir, lang, fonts: data.fonts, language: langDoc };
     const ui = this.ui = checkStoryUI(opts.ui ? opts.ui(gl, loop, parts) : new StoryUI(gl, loop, uiDoc, parts));
     if (Array.isArray(ui.talkWindows)) {
       const names = episode.commands.filter((c) => c.cmd === "TalkWindow" && !c.IgnoreData).map((c) => c.TargetAssetName);
@@ -192,7 +168,7 @@ export class StorySession {
       if (missing.length) throw new StoryCommandError(`${what}: talk windows not supported by this player: ${missing.join(", ")}`);
     }
     if (typeof ui.checkTexts === "function")
-      ui.checkTexts(storyTexts(episode, P, scene.settings.masterIdSettings, localize, titleTextId));
+      ui.checkTexts(storyTexts(episode, P, data.masterIds, localize, titleTextId));
     // UIAdvWidget.Init and SetLetterBoxSprite (AdvPlayer.Init): UpdateLetterBoxBands for the screen at load (the
     // drawing buffer size of the options, else the canvas size), before StartPlayTask fades the bands in
     if (gl && typeof ui.updateLetterBoxBands === "function") {
@@ -204,8 +180,8 @@ export class StorySession {
     // the sound manager with every cue of the episode ready; a story without its sound files (story.json `audio`
     // empty) plays no sound, with the voices off as in the game without voice data (Session.WithVoice false: the
     // lines advance by their length, the speakers get the timed pseudo lip sync)
-    const resolve = Audio.episodeResolver(episode);
-    const hasSounds = !!story.audio && Object.keys(story.audio).length > 0;
+    const resolve = Audio.episodeResolver(episode, data);
+    const hasSounds = Object.keys(data.parts.sounds || {}).length > 0;
     const webAudio = hasSounds && opts.sound !== false && typeof globalThis.AudioContext === "function";
     audio = this.audio = opts.audio ? opts.audio(resolve, loop, { assets: store })
       : webAudio ? new Audio(resolve, loop, { context: opts.audioContext || null, assets: store })
@@ -215,10 +191,10 @@ export class StorySession {
     // renderer and characters: the Character rows' preload, keyed TargetName-TargetAssetIndex (the first model of a
     // key is kept); IgnoreData rows are not preloaded. The story's shaders draw the stage and the post-processing,
     // each model's own shaders its character (models.js).
-    const storyLib = gl ? new ShaderLib(gl, "shaders", store) : null;
-    const renderer = this.renderer = gl ? new StoryRenderer(gl, storyLib, sc, quality, loop, { assets: store }) : null;
+    const storyLib = objects.lib;
+    const renderer = this.renderer = gl ? new StoryRenderer(gl, storyLib, sc, quality, loop, { assets: store, objects }) : null;
     if (renderer) renderer.filmGrain = opts.filmGrain ?? 0;
-    const modelOf = storyModels(gl, store, story, what);
+    const modelOf = storyModels(gl, data);
     for (const c of episode.commands) {
       if (c.cmd !== "Character" || c.IgnoreData) continue;
       if (characters.has(c.TargetName, c.TargetAssetIndex || 0)) continue;
@@ -229,15 +205,15 @@ export class StorySession {
       characters.add(c.TargetName, c.TargetAssetIndex || 0, ch);
       if (renderer) renderer.addCharacter(ch, { lib, model });
     }
-    if (renderer) await renderer.load("");
+    if (renderer) await renderer.load();
     await ui.load();
 
     // the interpreter
     const ctx = this.ctx = createStoryContext({
       loop, camera: sc.camera, field: sc.field, background: sc.background, fieldRenderer: sc.fieldRenderer,
       volume: sc.volume, characters, stages: sc.stageData, ui, audio, quality,
-      settings: { player: P, masterIds: scene.settings.masterIdSettings }, localize, lang, playbackMode: mode,
-      titleTextId, episode, story, assets: store, renderer, gl: this.gl });
+      settings: { player: P, masterIds: data.masterIds }, localize, lang, playbackMode: mode,
+      titleTextId, episode, story, data, objects, assets: store, renderer, gl: this.gl });
     this.lines = storyLines(episode);
     const { line, shortCutIndex } = storyStart(episode, { line: opts.line, row: opts.row });
     const core = this.core = new StoryPlayerCore(ctx, {
@@ -253,8 +229,7 @@ export class StorySession {
     sc.session = core.session;
     // AdvStage.Init: the stages' particle groups (before the features load, so that their materials load too)
     const stages = [...sc.stageData.values()];
-    const records = stages.some((st) => st.hasParticleEffects) ? new AnimRecords(scene, StoryCommandError) : null;
-    for (const st of stages) st.initParticleGroups(ctx, records);
+    for (const st of stages) st.initParticleGroups(ctx, objects);
     await installStoryFeatures(ctx, core, { random });                   // the feature modules' per-episode setup
     loop.on("render", () => this._renderHook());
 
diff --git a/src/story/silent-audio.js b/src/story/silent-audio.js
index c79eaac..78ab0eb 100644
--- a/src/story/silent-audio.js
+++ b/src/story/silent-audio.js
@@ -24,7 +24,7 @@ export class SilentAudio {
 
   cueOf(soundId) {
     const c = this.resolve(soundId);
-    const meta = this.assets.json(`audio/${c.sheet}/cues.json`)[c.cue];
+    const meta = c.meta;
     if (!meta) throw new Error(`cue ${c.cue} not in ${c.sheet}`);
     return { ...c, meta };
   }
diff --git a/src/story/simple/home/host.js b/src/story/simple/home/host.js
index da21a1a..16ff571 100644
--- a/src/story/simple/home/host.js
+++ b/src/story/simple/home/host.js
@@ -1,12 +1,13 @@
 import { join } from "../../../engine/core.js";
-import { applyState, ShaderLib } from "../../../engine/glsl.js";
+import { applyState } from "../../../engine/glsl.js";
 import { mat4, quat } from "../../../engine/math.js";
 import { CURVE_DEFAULTS, URPPost } from "../../../engine/postfx.js";
 import { GLTarget, GLTex } from "../../../engine/texture.js";
 import { blurPass, BLUR_SHADER, DualKawaseBlur, UIBlur } from "./blur.js";
+import { HomeScene } from "./objects.js";
 import { SpotCamera } from "./camera.js";
-import { imageBytes, parseGlb, textureInfo } from "./glb.js";
-import { checkSpotCamera, checkSpotStack, HOME_VIEW_MASK, spotVolumeStack } from "./post.js";
+import { parseGlb } from "./glb.js";
+import { checkSpotCamera, checkSpotStack, HOME_VIEW_MASK, spotMainCamera, spotVolumeStack } from "./post.js";
 import { materialQueue, ShaderInfo, sortDrawItems, SpotRoom } from "./room.js";
 import { skeletonDataVersion, spineRuntime, SpotSkeletonData } from "./spine.js";
 
@@ -39,7 +40,6 @@ export const NO_TAP_TARGET = "no tap target for the talk's character in the spot
 const CLEAR_SKYBOX = 1, CLEAR_SOLID = 2;
 const IDENTITY_Q = Object.freeze({ x: 0, y: 0, z: 0, w: 1 });
 
-const dirOf = (p) => { const i = p.lastIndexOf("/"); return i < 0 ? "" : p.slice(0, i); };
 const matrixOf = (a, what) => {
   if (!Array.isArray(a) || a.length !== 16) throw new Error(`${what}: not a 4 x 4 column-major matrix`);
   return Float32Array.from(a);
@@ -103,7 +103,7 @@ const white = (c) => !!c && c.r === 1 && c.g === 1 && c.b === 1;
 
 // The lighting state URP gives the main camera's draws in the spot, which holds no light: {pipeline, renderer,
 // keywords, globals, perObject}. Raises on a setting whose effect is not reproduced here.
-//   graphics        scene.json `player`: quality levels, pipeline assets, renderers
+//   graphics        story.scene `graphics`: quality levels, pipeline assets, renderers
 //   quality         the quality level (GameConfig.SetBaseQualityModeInternal: QualitySettings.SetQualityLevel(
 //                   BaseQualityMode)); its pipeline asset, else GraphicsSettings' default one
 //   rendererIndex   the camera's UniversalAdditionalCameraData m_RendererIndex (-1: the asset's default renderer)
@@ -124,16 +124,8 @@ const white = (c) => !!c && c.r === 1 && c.g === 1 && c.b === 1;
 // as black; its HDR decode values (1, 1, 0, 0) only scale that black.
 // ENGINE: unity_LightData (native per-object light data): x the offset of the per-object light indices (0), y their
 // count (0), z 1 (the main light's culling-mask factor; it multiplies the black main light).
-export const spotLighting = ({ graphics, quality, rendererIndex, renderSettings, lights = [], what = "home spot" }) => {
-  if (!graphics || !graphics.pipelines || !graphics.renderers)
-    throw new Error(`${what}: URP lighting needs the scene's render settings (scene.json player)`);
-  const level = (graphics.qualityLevels || [])[quality];
-  if (!level) throw new Error(`${what}: quality level ${quality} is not in the render settings`);
-  const pipeName = level.customRenderPipeline || graphics.defaultPipeline, pipe = graphics.pipelines[pipeName];
-  if (!pipe) throw new Error(`${what}: pipeline asset ${pipeName} is not in the render settings`);
-  const index = rendererIndex === undefined || rendererIndex === null || rendererIndex < 0 ? pipe.m_DefaultRendererIndex : rendererIndex;
-  const rendName = (pipe.m_RendererDataList || [])[index], rend = graphics.renderers[rendName];
-  if (!rend) throw new Error(`${what}: renderer ${index} of ${pipeName} is not in the render settings`);
+export const spotLighting = ({ pipeline: pipe, renderer: rend, renderSettings, lights = [], lightmaps = [], what = "home spot" }) => {
+  const pipeName = pipe.m_Name, rendName = rend.m_Name;
   if (rend.m_RenderingMode !== RENDERING_FORWARD)
     throw new Error(`${what}: renderer ${rendName} rendering mode ${rend.m_RenderingMode} (only Forward is reproduced)`);
   for (const f of rend.m_RendererFeatures || []) {
@@ -146,7 +138,7 @@ export const spotLighting = ({ graphics, quality, rendererIndex, renderSettings,
   if (!rs) throw new Error(`${what}: the Spot scene's RenderSettings (home.sceneRoot.renderSettings) are missing`);
   if (rs.m_Fog) throw new Error(`${what}: scene fog is not reproduced`);
   if (rs.m_Sun) throw new Error(`${what}: RenderSettings.sun is not reproduced`);
-  if (rs.lightmaps) throw new Error(`${what}: lightmaps are not reproduced`);
+  if (lightmaps.length) throw new Error(`${what}: lightmaps are not reproduced`);
   if (rs.m_AmbientMode !== AMBIENT_FLAT || !white(rs.m_AmbientSkyColor) || rs.m_AmbientIntensity !== 1)
     throw new Error(`${what}: ambient mode ${rs.m_AmbientMode} is not reproduced (only a white Flat ambient)`);
   if (rs.m_SkyboxMaterial || rs.m_CustomReflection || rs.m_DefaultReflectionMode !== REFLECTION_SKYBOX)
@@ -180,47 +172,53 @@ export const spotLighting = ({ graphics, quality, rendererIndex, renderSettings,
     unity_SHAr: [0, 0, 0, 1], unity_SHAg: [0, 0, 0, 1], unity_SHAb: [0, 0, 0, 1],
     unity_SHBr: [0, 0, 0, 0], unity_SHBg: [0, 0, 0, 0], unity_SHBb: [0, 0, 0, 0], unity_SHC: [0, 0, 0, 0],
   };
-  return { pipeline: pipeName, renderer: rendName, keywords, globals, perObject };
+  return { pipeline: pipe, renderer: rend, keywords, globals, perObject };
 };
 
 export class SimpleHomeHost {
   // gl: WebGL2 context or null; store: the story's AssetStore; loop: the session's PlayerLoop; host: host/host.json;
   // opts: {camera: {near, far, clearFlags, clearColor: [r, g, b, a], orthographicSize, rendererIndex, hdr, volumeMask}
   //        of the main camera in the spot (post.js spotMainCamera),
-  //        graphics: scene.json `player` (the render settings tree), quality: the quality level (BaseQualityMode),
+  //        graphics: story.scene `graphics` (the render settings tree), quality: the quality level (BaseQualityMode),
   //        post: {lib: the ShaderLib of the story's shaders (the URP post programs), textures: scene.json
   //               `postTextures` (by renderer name), filmGrain: multiplier of FilmGrain.intensity (default 0: none),
   //               screenScale(width): the game's screen pixels per pixel of the target (default 1)},
   //        spine: a Spine runtime (default globalThis.spine; null for none)}
   // A drawn host needs graphics, quality, the camera's orthographicSize (URP's lighting state, spotLighting) and
   // post.lib (the main camera's post chain).
-  static async create(gl, store, loop, host, opts = {}) {
-    const h = new SimpleHomeHost(gl, store, loop, host, opts);
+  static async create(gl, store, loop, data, opts = {}) {
+    const h = new SimpleHomeHost(gl, store, loop, data, opts);
     try { if (gl) await h._upload(); } catch (e) { h.dispose(); throw e; }
     return h;
   }
 
-  constructor(gl, store, loop, host, opts = {}) {
-    if (!host || host.kind !== "home" || !host.home) throw new Error("host.json: not a home host");
-    const home = this.home = host.home;
-    const cam = opts.camera || {};
+  constructor(gl, store, loop, data, opts = {}) {
+    const host = data.host;
+    if (host?.kind !== "home" || !host.home) throw new Error("not a home host product");
+    const home = this.home = host.home, objects = this.objects = opts.objects;
+    this.data = data;
+    const scene = this.scene = new HomeScene(data, objects);
+    const main = objects.prefab(data.scene.prefabs.cameraManager), manager = main.find("CameraManager").c.fields;
+    const mainPath = main.pathOf(manager._mainCamera);
+    const cam = opts.camera || spotMainCamera(main.fields(mainPath, "Camera"),
+      main.fields(mainPath, "UniversalAdditionalCameraData"), scene.camera ? { camera: scene.camera } : null);
     this.gl = gl; this.store = store; this.loop = loop;
     this.missing = [];
-    this.spot = store.json(home.spot);
-    this.spineDir = join(dirOf(home.spot), "spine");
-    this.shaderBase = dirOf(home.shaders.index);
-    this.shaders = new ShaderInfo(store, this.shaderBase);
-    this.room = new SpotRoom(parseGlb(store.bytes(home.room)), home, this.shaders);
-    const settings = this.spot.situationSettings;
-    const objRoot = home.sceneRoot ? home.sceneRoot.objRoot : null;
-    this.rootMatrix = objRoot ? mat4.trs(objRoot.position, objRoot.rotation, objRoot.scale) : mat4.identity();
+    this.spot = data.document(home.parts.spot, "spot.json");
+    this.spineDir = data.file(home.parts.spot, "spine");
+    this.shaders = new ShaderInfo(objects);
+    const summary = data.document(home.parts.room, "room.json");
+    this.room = new SpotRoom(parseGlb(store.bytes(data.file(home.parts.room, summary.glb))), summary, home.backgroundState, objects, this.shaders);
+    const settings = this.spot.situationSettings, objRoot = scene.objRoot;
+    const roomRoot = scene.background.nodes.get(scene.background.root.name).node;
+    this.rootMatrix = scene.rootMatrix;
     this.backgroundMatrix = backgroundMatrix(settings, objRoot);
-    this.roomMatrix = roomMatrix(this.backgroundMatrix, home.roomRoot);
-    this.roomInverse = roomInverse(settings, objRoot, home.roomRoot);
+    this.roomMatrix = roomMatrix(this.backgroundMatrix, roomRoot);
+    this.roomInverse = roomInverse(settings, objRoot, roomRoot);
     this.camera = new SpotCamera(loop, settings, { near: cam.near, far: cam.far });
     this.orthographicSize = cam.orthographicSize;
     this.rendererIndex = cam.rendererIndex;
-    this.graphics = opts.graphics || null;
+    this.graphics = data.scene.graphics;
     this.quality = opts.quality;
     this.clearFlags = cam.clearFlags ?? CLEAR_SOLID;
     this.clearColor = colorOf(cam.clearColor);
@@ -230,12 +228,12 @@ export class SimpleHomeHost {
     this.cameraSettings = cam;
     this.postOpts = opts.post || {};
     this.blur = new UIBlur(loop);
-    this.blurParams = home.blur;
+    this.blurParams = objects.uiBlur(this.graphics.graphics, 0);
     this.skeletons = [];
     this.spineReason = null;
     this._hooks = [];
     this._initSpine(opts.spine !== undefined ? opts.spine : globalThis.spine);
-    if (home.talk === "tap" && !this.tapTarget(home.characterId)) this.missing.push(NO_TAP_TARGET);
+    if (data.story.host.talk === "tap" && !this.tapTarget(data.story.host.characterId)) this.missing.push(NO_TAP_TARGET);
   }
 
   // SpotSpineCharacter -> SkeletonAnimation, each started at its initial animation's end state (spine.js)
@@ -256,17 +254,16 @@ export class SimpleHomeHost {
     });
     this.spineData = new SpotSkeletonData(runtime, used, (f) => this.store.text(join(this.spineDir, f)),
                                           (f) => this.store.bytes(join(this.spineDir, f)));
-    // host.json home.spineCharacters (by path): the MeshRenderer's sortingOrder and the atlas pages' materials
-    const extra = new Map((this.home.spineCharacters || []).map((x) => [x.path, x]));
+    const extra = new Map(chars.map((c) => [c.path, this.scene.spine(c.path)]));
     const named = new Map();
-    for (const c of chars) {
-      for (const [page, name] of Object.entries((extra.get(c.path) || {}).pageMaterials || {})) {
-        if (named.has(page) && named.get(page) !== name)
-          throw new Error(`home.spineCharacters: atlas page ${page} has the materials ${named.get(page)} and ${name}`);
-        named.set(page, name);
-      }
+    for (const { pages } of extra.values()) for (const [page, material] of pages) {
+      if (named.has(page) && named.get(page).id !== material.id) throw new Error(`atlas page ${page}: conflicting materials`);
+      named.set(page, material);
     }
-    this.pageMaterials = new Map(this.spineData.pages().map((p) => [p, this._pageMaterial(p, named.get(p))]));
+    this.pageMaterials = new Map(this.spineData.pages().map((page) => {
+      if (!named.has(page)) throw new Error(`atlas page ${page}: no material`);
+      return [page, named.get(page)];
+    }));
     for (const c of chars) {
       const skeleton = this.spineData.skeleton(c.skeletonData, c.animation);
       skeleton.applyEndState();
@@ -279,33 +276,20 @@ export class SimpleHomeHost {
     this._on("update", (loop) => { for (const s of this.skeletons) s.skeleton.update(loop.deltaTime); });
   }
 
-  // the material of an atlas page (SpineAtlasAsset.materials[page]): the one host.json names for the page, else the
-  // only Spine material, else the one named after the page as spine-unity's importer names it ("<page>_Material").
-  // The record (advui material form) is brought to the room material form: shader name, texEnvs with [x, y] pairs.
-  _pageMaterial(page, name = null) {
-    const mats = this.home.spineMaterials || {}, list = Object.values(mats);
-    const m = name ? mats[name] : list.length === 1 ? list[0] : mats[`${page.replace(/\.[^.]*$/, "")}_Material`];
-    if (!m) throw new Error(`home.spineMaterials: no material ${name || ""} for atlas page ${page}`);
-    const shader = typeof m.shader === "string" ? m.shader : m.shader && m.shader.shader;
-    const matName = m.name || m.material;
-    if (!this.shaders.has(shader)) throw new Error(`home.spineMaterials ${matName}: shader ${shader} not packed`);
-    const pair = (v, d) => (Array.isArray(v) ? v : v ? [v.x, v.y] : d);
-    const texEnvs = Object.fromEntries(Object.entries(m.texEnvs || m.textures || {}).map(([slot, t]) =>
-      [slot, { scale: pair(t.scale, [1, 1]), offset: pair(t.offset, [0, 0]) }]));
-    return { name: matName, shader, keywords: m.keywords || [], floats: m.floats || {}, colors: m.colors || {},
-             renderQueue: m.renderQueue ?? -1, texEnvs };
-  }
-
   _on(phase, fn) { this.loop.on(phase, fn); this._hooks.push([phase, fn]); }
 
   // ------------------------------------------------------------------------------------------------ GPU resources
   // URP's lighting state of the main camera in the spot (spotLighting): checked before any GL call
   _lighting() {
-    const home = this.home, root = home.sceneRoot || {}, what = `home spot ${home.spotId}`;
-    if (typeof this.orthographicSize !== "number")
-      throw new Error(`${what}: the main camera's orthographic size (opts.camera.orthographicSize) is needed to draw`);
-    return spotLighting({ graphics: this.graphics, quality: this.quality, rendererIndex: this.rendererIndex,
-                          renderSettings: root.renderSettings, lights: [...(root.lights || []), ...(home.lights || [])], what });
+    const scene = this.scene, what = `home spot ${this.home.spotId}`, o = this.objects;
+    if (typeof this.orthographicSize !== "number") throw new Error(`${what}: the main camera's orthographic size is needed`);
+    if (!this.graphics) throw new Error(`${what}: URP lighting needs the scene's render settings`);
+    const quality = this.store.objectJson(this.graphics.quality).m_QualitySettings[this.quality];
+    if (!quality) throw new Error(`${what}: quality level ${this.quality} is missing`);
+    const pipeline = o.mono(quality.customRenderPipeline || this.store.objectJson(this.graphics.graphics).m_CustomRenderPipeline);
+    const renderer = o.mono(pipeline.m_RendererDataList[this.rendererIndex < 0 ? pipeline.m_DefaultRendererIndex : this.rendererIndex]);
+    return spotLighting({ pipeline, renderer: { ...renderer, m_RendererFeatures: renderer.m_RendererFeatures.map((r) => o.mono(r)) },
+      renderSettings: scene.renderSettings, lightmaps: scene.lightmaps, lights: scene.lights, what });
   }
 
   // the keywords of a material's programs: its own and the camera's global lighting keywords
@@ -317,14 +301,14 @@ export class SimpleHomeHost {
     checkSpotCamera(this.cameraSettings, what);
     if (!P.lib) throw new Error(`${what}: the main camera's post-processing needs the story's shaders (opts.post.lib)`);
     // UniversalRenderPipeline.InitializeStackedCameraData: HDR = Camera.allowHDR && the pipeline asset's supportsHDR
-    this.hdr = this.cameraHDR && !!this.graphics.pipelines[this.lighting.pipeline].m_SupportsHDR;
-    const stack = checkSpotStack(spotVolumeStack(this.home, this.volumeMask, what), what);
+    this.hdr = this.cameraHDR && !!this.lighting.pipeline.m_SupportsHDR;
+    const stack = checkSpotStack(spotVolumeStack(this.scene.volumes, this.volumeMask, what), what);
     this.filmGrain = P.filmGrain ?? 0;
     const G = stack.FilmGrain, grain = G.intensity * this.filmGrain > 0 && G.type !== 10;
-    const renderer = this.lighting.renderer, tex = P.textures && P.textures[renderer];
-    if (grain && !(tex && Array.isArray(tex.filmGrainTex)))
-      throw new Error(`${what}: the film grain textures of renderer ${renderer} are not in the story's postTextures`);
-    return { stack, grainDescs: grain ? tex.filmGrainTex : null };
+    const renderer = this.lighting.renderer;
+    const textures = this.objects.mono(renderer.postProcessData)?.textures;
+    if (grain && !textures?.filmGrainTex) throw new Error(`${what}: film grain textures of renderer ${renderer.m_Name} are missing`);
+    return { stack, grainDescs: grain ? textures.filmGrainTex.map((r) => this.objects.id(r, "Texture2D")) : null };
   }
 
   async _upload() {
@@ -332,8 +316,9 @@ export class SimpleHomeHost {
     const post = this._postSetup();
     this.volumeStack = post.stack;
     const gl = this.gl;
-    this.lib = new ShaderLib(gl, this.shaderBase, this.store);
+    this.lib = this.objects.lib;
     this.vao = gl.createVertexArray();
+    gl.bindVertexArray(this.vao);
     this.tex = {
       white: GLTex.solid(gl, [255, 255, 255, 255], "white"), black: GLTex.solid(gl, [0, 0, 0, 255], "black"),
       gray: GLTex.solid(gl, [128, 128, 128, 255], "gray"), bump: GLTex.solid(gl, [128, 128, 255, 255], "bump"),
@@ -353,7 +338,6 @@ export class SimpleHomeHost {
       if (!byAccessor.has(index)) byAccessor.set(index, buf(data, gl.ARRAY_BUFFER));
       return byAccessor.get(index);
     };
-    const glbTextures = new Map();
     for (const part of this.room.parts) {
       const p = part.primitive;
       part.gpu = { in_POSITION0: { buffer: attr(p.positionAccessor, p.positions), size: 3, type: gl.FLOAT, normalized: false },
@@ -361,10 +345,9 @@ export class SimpleHomeHost {
                    index: buf(p.indices, gl.ELEMENT_ARRAY_BUFFER), count: p.indices.length };
       if (p.normals) part.gpu.in_NORMAL0 = { buffer: attr(p.normalAccessor, p.normals), size: 3, type: gl.FLOAT, normalized: false };
       const texs = {};
-      for (const [slot, t] of Object.entries(part.material.texEnvs || {})) {
+      for (const [slot, t] of Object.entries(part.material.textures || {})) {
         if (t.texture === null || t.texture === undefined) continue;
-        if (!glbTextures.has(t.texture)) glbTextures.set(t.texture, await this._glbTexture(t.texture));
-        texs[slot] = glbTextures.get(t.texture);
+        texs[slot] = await this.objects.texture(t.texture.id);
       }
       part.textures = texs;
       for (const pass of part.passes) {
@@ -383,20 +366,12 @@ export class SimpleHomeHost {
     this.kawase = new DualKawaseBlur(gl, this.lib);
     // the main camera's post chain: the renderer's film grain textures (only when the grain is drawn), its LUT
     this.urp = new URPPost(gl, this.postOpts.lib, { vao: this.vao });
-    this.grain = post.grainDescs ? await URPPost.loadGrain(gl, post.grainDescs, (d) => GLTex.load(gl, "", d)) : [];
+    this.grain = post.grainDescs ? await URPPost.loadGrain(gl, post.grainDescs, (id) => this.objects.texture(id)) : [];
     this.urp.initLut();
     this.cameraColor = null;
     this.room.glb = null;                 // the file's bytes are no longer needed
   }
 
-  // an embedded glb image with its glTF sampler, rows flipped to Unity's bottom-left origin
-  async _glbTexture(index) {
-    const glb = this.room.glb, info = textureInfo(glb, index), im = imageBytes(glb, info.source);
-    const bmp = await createImageBitmap(new Blob([im.bytes], { type: im.mimeType }),
-                                        { premultiplyAlpha: "none", colorSpaceConversion: "none", imageOrientation: "flipY" });
-    return this._texture(bmp, info.sampler, im.name);
-  }
-
   // the default reflection cube of the spot (spotLighting): black, 1 x 1 per face
   _blackCube() {
     const gl = this.gl, t = gl.createTexture(), px = new Uint8Array([0, 0, 0, 255]);
@@ -411,29 +386,10 @@ export class SimpleHomeHost {
     return tex;
   }
 
-  // an atlas page PNG of the spot's spine directory
-  // ENGINE: atlas page texture import settings are not in the data; bilinear, clamped, no mipmaps here.
   async _pageTexture(page) {
-    const gl = this.gl, bmp = await this.store.image(join(this.spineDir, page));
-    return this._texture(bmp, { magFilter: gl.LINEAR, minFilter: gl.LINEAR, wrapS: gl.CLAMP_TO_EDGE, wrapT: gl.CLAMP_TO_EDGE }, page);
-  }
-
-  _texture(bmp, s, label) {
-    const gl = this.gl, t = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, t);
-    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
-    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, gl.RGBA, gl.UNSIGNED_BYTE, bmp);
-    const mips = s.minFilter !== gl.LINEAR && s.minFilter !== gl.NEAREST;
-    if (mips) gl.generateMipmap(gl.TEXTURE_2D);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, s.magFilter);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, s.minFilter);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, s.wrapS);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, s.wrapT);
-    const tex = new GLTex(gl, t, bmp.width, bmp.height, label);
-    bmp.close();
-    this.textures.push(tex);
-    return tex;
+    const material = this.pageMaterials.get(page), texture = material.textures._MainTex?.texture;
+    if (!texture) throw new Error(`atlas page ${page}: no main texture`);
+    return this.objects.texture(texture.id);
   }
 
   // a framebuffer drawing into the caller's target with a depth-stencil buffer of our own
@@ -577,7 +533,7 @@ export class SimpleHomeHost {
   _materialSheets(mat, textures) {
     const s = { ...(mat.floats || {}) };
     for (const [k, c] of Object.entries(mat.colors || {})) s[k] = c;
-    for (const [k, t] of Object.entries(mat.texEnvs || {})) s[`${k}_ST`] = [t.scale[0], t.scale[1], t.offset[0], t.offset[1]];
+    for (const [k, t] of Object.entries(mat.textures || {})) s[`${k}_ST`] = [t.scale.x, t.scale.y, t.offset.x, t.offset.y];
     for (const [k, tex] of Object.entries(textures)) {
       s[k] = tex;
       s[`${k}_TexelSize`] = [1 / tex.width, 1 / tex.height, tex.width, tex.height];
@@ -623,6 +579,8 @@ export class SimpleHomeHost {
   _uploadSkeleton(s) {
     const mesh = s.mesh = s.skeleton.buildMesh(), gl = this.gl;
     if (!gl) return;
+    // Index buffers belong to the bound VAO; uploads must not change a preceding character's vertex array.
+    gl.bindVertexArray(this.vao);
     if (!s.gpu) {
       const b = () => { const x = gl.createBuffer(); this.buffers.push(x); return x; };
       s.gpu = { in_POSITION0: { buffer: b(), size: 3, type: gl.FLOAT, normalized: false },
diff --git a/src/story/simple/home/objects.js b/src/story/simple/home/objects.js
new file mode 100644
index 0000000..664d72b
--- /dev/null
+++ b/src/story/simple/home/objects.js
@@ -0,0 +1,71 @@
+import { Prefab, componentClass } from "../../../engine/prefab.js";
+import { mat4, quat } from "../../../engine/math.js";
+
+// Scene placement, camera and component registrations retained by the home host product.
+export class HomeScene {
+  constructor(data, objects) {
+    this.objects = objects;
+    const home = data.host.home, assets = data.assets;
+    const roots = home.scene.filter((id) => assets.object(id).class === "GameObject");
+    this.scene = new Prefab({ key: "home scene", nodes: [] });
+    if (roots.length) this.scene = Prefab.fromObjects(assets, roots);
+    this.background = objects.prefab(home.background);
+    this.situation = objects.prefab(home.situation);
+    const sceneRoots = this.components(this.scene, "SpotSceneRoot");
+    if (sceneRoots.length > 1) throw new Error("home scene: multiple SpotSceneRoot components");
+    const fields = sceneRoots[0]?.fields;
+    const transform = fields?._objRoot ? this.scene.transformOf(fields._objRoot) : null;
+    this.objRoot = transform ? worldTRS(transform) : null;
+    this.rootMatrix = transform ? transform.localToWorld() : mat4.identity();
+    this.camera = fields?._sceneCamera ? this.scene.componentOf(fields._sceneCamera, "Camera").fields : null;
+    this.renderSettings = this.setting(home.scene, "RenderSettings");
+    this.lightmaps = this.setting(home.scene, "LightmapSettings")?.m_Lightmaps || [];
+    this.volumes = []; this.lights = [];
+    for (const p of [this.scene, this.background, this.situation]) {
+      const active = (path) => p === this.background
+        ? home.backgroundState.nodes[path]?.active ?? p.activeInHierarchy(path) : p.activeInHierarchy(path);
+      for (const { path, node, fields: f } of this.components(p, "Volume"))
+        this.volumes.push({ path, layer: node.layer, active: active(path), fields: f,
+          profile: objects.profile(f.sharedProfile) });
+      for (const cls of ["Light", "ReflectionProbe"])
+        for (const { path, fields: f } of this.components(p, cls))
+          this.lights.push({ ...f, type: cls, path, active: active(path) });
+    }
+  }
+
+  setting(ids, cls) {
+    const found = ids.filter((id) => this.objects.assets.object(id).class === cls);
+    if (found.length > 1) throw new Error(`home scene: multiple ${cls} objects`);
+    return found.length ? this.objects.assets.objectJson(found[0]) : null;
+  }
+
+  components(prefab, cls) {
+    const out = [];
+    for (const [path, { node }] of prefab.nodes) for (const c of node.components)
+      if (componentClass(c) === cls) out.push({ path, node, fields: c.fields });
+    return out;
+  }
+
+  spine(path) {
+    const p = this.situation, c = p.fields(path, "SpotSpineCharacter");
+    const anim = p.componentOf(c._animation, "SkeletonAnimation").fields;
+    const renderer = p.fields(p.pathOf(c._animation), "MeshRenderer");
+    const skeleton = this.objects.mono(anim.skeletonDataAsset), pages = new Map();
+    for (const ref of skeleton.atlasAssets) {
+      const atlas = this.objects.mono(ref), id = this.objects.id(atlas.atlasFile, "TextAsset");
+      const lines = new TextDecoder().decode(this.objects.assets.objectBytes(id, "data")).split(/\r?\n/).map((s) => s.trim());
+      const names = lines.filter((s, i) => s && !s.includes(":") && lines[i + 1]?.startsWith("size:"));
+      if (names.length !== atlas.materials.length) throw new Error(`${path}: atlas page/material count mismatch`);
+      names.forEach((page, i) => pages.set(page, this.objects.material(atlas.materials[i])));
+    }
+    return { pages, sortingOrder: renderer.m_SortingOrder };
+  }
+}
+
+const worldTRS = (t) => {
+  let rotation = t.localRotation;
+  for (let p = t.parent; p; p = p.parent) rotation = quat.mul(p.localRotation, rotation);
+  const m = t.localToWorld();
+  return { position: t.worldPosition(), rotation,
+    scale: { x: Math.hypot(m[0], m[1], m[2]), y: Math.hypot(m[4], m[5], m[6]), z: Math.hypot(m[8], m[9], m[10]) } };
+};
diff --git a/src/story/simple/home/post.js b/src/story/simple/home/post.js
index 475f375..cd4e0de 100644
--- a/src/story/simple/home/post.js
+++ b/src/story/simple/home/post.js
@@ -52,46 +52,24 @@ export const checkSpotCamera = (cam, what = "home spot") => {
   return cam;
 };
 
-// The spot's Volumes in registration order (Volume.OnEnable): the Spot scene's, loaded before any spot is placed, then
-// the placed background prefab's (SpotSceneRoot.SetObject). Records (host.json): {path, active (activeInHierarchy),
-// enabled, isGlobal, weight, priority, blendDistance, layer, profile, components: [{class, active, <overridden
-// parameter>: value}]}.
-export const spotVolumes = (home) =>
-  [...((home.sceneRoot && home.sceneRoot.volumes) || []), ...(home.volume ? [home.volume] : [])];
-
-// a profile component of a record in the form URPPost.evaluateStack reads (overridden parameters as
-// {m_OverrideState, m_Value}); texture parameters are refused (the host data does not carry the textures)
-const profileComponent = (c, where) => {
-  const { class: cls, active, ...params } = c;
-  const kinds = VOLUME_PARAMS[cls];
-  if (!kinds) throw new Error(`${where}: volume component ${cls} not implemented`);
-  const out = { asset: cls, active: active ? 1 : 0 };
-  for (const [k, v] of Object.entries(params)) {
-    if (!kinds[k]) throw new Error(`${where}: ${cls}.${k}: unknown parameter`);
-    if (kinds[k] === "n" && VOLUME_DEFAULTS[cls][k] === null)
-      throw new Error(`${where}: ${cls}.${k}: texture parameters not implemented`);
-    out[k] = { m_OverrideState: 1, m_Value: v };
-  }
-  return out;
-};
-
-// VolumeManager.Update(stack, trigger, layerMask) for the spot: the default state, then the registered volumes whose
-// layer is in the mask, sorted by priority (VolumeCollection.SortByPriority: a stable insertion sort), each skipped
-// when disabled, without a profile or without weight; a global volume blends by Mathf.Clamp01(weight). A local volume
-// (blended by its colliders' distance to the trigger) is refused.
-export const spotVolumeStack = (home, mask = HOME_VIEW_MASK, what = "home spot") => {
-  const registered = spotVolumes(home).filter((v) => {
-    if (typeof v.active !== "boolean") throw new Error(`${what}: Volume ${v.path}: activeInHierarchy is not in the host data`);
-    return v.active && v.enabled;
-  });
-  const grabbed = registered.filter((v) => ((mask >>> v.layer) & 1) === 1);
-  const sorted = grabbed.map((v, i) => [v, i]).sort((a, b) => (a[0].priority - b[0].priority) || (a[1] - b[1])).map(([v]) => v);
+// Volume registrations in scene order, then the placed prefabs; component fields and profile objects stay native.
+export const spotVolumeStack = (volumes, mask = HOME_VIEW_MASK, what = "home spot") => {
+  for (const v of volumes) if (typeof v.active !== "boolean") throw new Error(`${what}: Volume ${v.path}: activeInHierarchy is not in the host data`);
+  const sorted = volumes.filter((v) => v.active && v.fields.m_Enabled && ((mask >>> v.layer) & 1))
+    .map((v, i) => [v, i]).sort((a, b) => (a[0].fields.priority - b[0].fields.priority) || (a[1] - b[1]));
   const blended = [];
-  for (const v of sorted) {
-    if (!v.profile || !(v.weight > 0)) continue;
-    if (!v.isGlobal) throw new Error(`${what}: local Volume ${v.path} (blend distance ${v.blendDistance}) not implemented`);
-    const where = `${what}: Volume ${v.path} profile ${v.profile}`;
-    blended.push({ profile: { components: (v.components || []).map((c) => profileComponent(c, where)) }, weight: v.weight });
+  for (const [v] of sorted) {
+    const f = v.fields;
+    if (!v.profile || !(f.weight > 0)) continue;
+    if (!f.m_IsGlobal) throw new Error(`${what}: local Volume ${v.path} (blend distance ${f.blendDistance}) not implemented`);
+    for (const c of v.profile.components) {
+      if (!c.active) continue;
+      const kinds = VOLUME_PARAMS[c.asset];
+      if (!kinds) throw new Error(`${what}: volume component ${c.asset} not implemented`);
+      for (const [k, p] of Object.entries(c)) if (p?.m_OverrideState && kinds[k] === "n" && VOLUME_DEFAULTS[c.asset][k] === null)
+        throw new Error(`${what}: ${c.asset}.${k}: texture parameters not implemented`);
+    }
+    blended.push({ profile: v.profile, weight: f.weight });
   }
   return URPPost.evaluateStack(blended);
 };
diff --git a/src/story/simple/home/room.js b/src/story/simple/home/room.js
index cb3e3e0..3a2ba9a 100644
--- a/src/story/simple/home/room.js
+++ b/src/story/simple/home/room.js
@@ -1,4 +1,3 @@
-import { join } from "../../../engine/core.js";
 import { mat4 } from "../../../engine/math.js";
 import { roomMeshes } from "./glb.js";
 
@@ -32,23 +31,14 @@ export const parseQueueTag = (v) => {
   return base + (m[2] ? Number(m[2].replace(/\s/g, "")) : 0);
 };
 
-// The parsed shader summaries of a packed shader directory (shaders.json + <name>.json), read from the store
+// Parsed shader objects addressed by id, with the product's Shader.Find name table.
 export class ShaderInfo {
-  constructor(store, base) {
-    this.store = store; this.base = base;
-    this.index = new Map(store.json(join(base, "shaders.json")).map((r) => [r.name, r]));
-    this.parsed = new Map();
-  }
+  constructor(objects) { this.objects = objects; }
 
-  has(name) { return this.index.has(name); }
+  has(name) { return !!this.objects.shaderNames[name] || this.objects.assets.hasObject(name); }
 
   info(name) {
-    if (!this.parsed.has(name)) {
-      const rec = this.index.get(name);
-      if (!rec) throw new Error(`shader not packed: ${name}`);
-      this.parsed.set(name, this.store.json(join(this.base, rec.parsed)));
-    }
-    return this.parsed.get(name);
+    return this.objects.shaderInfo(this.objects.shaderNames[name] || name);
   }
 
   // the SubShader URP uses: the first whose RenderPipeline tag is absent or UniversalPipeline
@@ -95,21 +85,25 @@ const distance = (M, c, cam) => {
   return Math.hypot(p.x - cam.x, p.y - cam.y, p.z - cam.z);
 };
 
-// The room: glb nodes joined with host.json roomNodes (same order) and roomMaterials (glb material order).
+// Room geometry and its summary share node and material order. The host supplies activation and queue overrides.
 export class SpotRoom {
-  constructor(glb, home, shaders) {
+  constructor(glb, summary, state, objects, shaders) {
     this.glb = glb;
     this.meshes = roomMeshes(glb);
-    const nodes = home.roomNodes, mats = home.roomMaterials;
+    const nodes = summary.nodes.map(({ path }) => {
+      if (!state.nodes[path]) throw new Error(`room node ${path}: no background state`);
+      return { path, ...state.nodes[path] };
+    });
+    const mats = summary.materialIds.map((id) => objects.material(id));
     if (!Array.isArray(nodes) || nodes.length !== this.meshes.length)
-      throw new Error(`home.roomNodes: ${nodes ? nodes.length : "none"} entries for ${this.meshes.length} glb nodes`);
+      throw new Error(`room nodes: ${nodes.length} entries for ${this.meshes.length} glb nodes`);
     const glbMats = glb.json.materials || [];
     if (!Array.isArray(mats) || mats.length !== glbMats.length)
-      throw new Error(`home.roomMaterials: ${mats ? mats.length : "none"} entries for ${glbMats.length} glb materials`);
+      throw new Error(`room materials: ${mats.length} entries for ${glbMats.length} glb materials`);
     mats.forEach((m, i) => {
-      if (glbMats[i].name !== undefined && m.name !== glbMats[i].name)
-        throw new Error(`home.roomMaterials[${i}] ${m.name} is not glb material ${glbMats[i].name}`);
-      if (!shaders.has(m.shader)) throw new Error(`home.roomMaterials[${i}]: shader ${m.shader} not packed`);
+      if (glbMats[i].name !== undefined && m.material !== glbMats[i].name)
+        throw new Error(`room material ${m.material} is not glb material ${glbMats[i].name}`);
+      if (!shaders.has(m.shader)) throw new Error(`room material ${m.material}: shader ${m.shader} not packed`);
     });
     this.materials = mats;
     this.nodes = nodes;
diff --git a/src/story/simple/objects.js b/src/story/simple/objects.js
new file mode 100644
index 0000000..08eecea
--- /dev/null
+++ b/src/story/simple/objects.js
@@ -0,0 +1,23 @@
+// The host's visible prefab subtrees and the hierarchy/animation targets that support them.
+export const hostUIRoots = (host, objects) => {
+  const ui = host.kind === "home" ? host.prefabs.spotWidget : host.prefabs.resultWidget;
+  const p = objects.prefab(ui), overlay = host.overlayRoot.path;
+  const sequences = host.openedSequences.filter((r) => r.prefab === ui).map((r) => r.path);
+  if (host.kind === "home") {
+    const w = p.find("UISpotWidget").c.fields;
+    for (const key of ["_transitionIn", "_transitionOut", "_fadeIn", "_fadeOut"])
+      if (w[key]) sequences.push(p.pathOf(w[key]));
+  }
+  const subtrees = [overlay, ...sequences];
+  if (host.kind === "home") subtrees.push(`${overlay.slice(0, overlay.lastIndexOf("/"))}/Fade`);
+  const targets = [];
+  for (const path of sequences) {
+    const s = p.fields(path, "DOTweenSequence");
+    for (const e of s._list) for (const call of e._tweenEvent?.m_PersistentCalls?.m_Calls || [])
+      if (call.m_Target) targets.push(p.pathOf(call.m_Target));
+  }
+  const include = (path) => subtrees.some((s) => path === s || path.startsWith(`${s}/`) || s.startsWith(`${path}/`))
+    || targets.some((s) => path === s || s.startsWith(`${path}/`));
+  return [{ id: ui, include, texts: false },
+    { id: host.kind === "home" ? host.prefabs.spotLetterbox : host.prefabs.resultBackground, texts: false }];
+};
diff --git a/src/story/simple/render.js b/src/story/simple/render.js
index db1bf01..326bf22 100644
--- a/src/story/simple/render.js
+++ b/src/story/simple/render.js
@@ -52,7 +52,17 @@ export class CameraTargetRenderer {
   }
 }
 
-export const cameraTargetDesc = (host) => (host && host.cameraTarget ? host.cameraTarget : DEFAULT_CAMERA_TARGET);
+export const cameraTargetDesc = (host, objects) => {
+  if (!host?.cameraTarget) return DEFAULT_CAMERA_TARGET;
+  const p = objects.prefab(host.cameraTarget), f = p.find("CameraTargetRenderer").c.fields;
+  const cameraPath = p.pathOf(f._captureCamera), stagePath = p.pathOf(f._stage);
+  const camera = p.fields(cameraPath, "Camera"), node = p.nodes.get(cameraPath).node;
+  return { container: p.nodes.get(cameraPath.slice(0, cameraPath.lastIndexOf("/"))).node,
+    stage: p.nodes.get(stagePath).node,
+    camera: { ...node, fieldOfView: camera["field of view"], near: camera["near clip plane"], far: camera["far clip plane"],
+      orthographic: !!camera.orthographic, orthographicSize: camera["orthographic size"],
+      clearFlags: camera.m_ClearFlags, backgroundColor: camera.m_BackGroundColor } };
+};
 
 // The GL side: Live2D drawings of the loaded characters and the slots' capture textures.
 export class SimpleCaptureRenderer {
diff --git a/src/story/simple/session.js b/src/story/simple/session.js
index f7210cd..0427f71 100644
--- a/src/story/simple/session.js
+++ b/src/story/simple/session.js
@@ -1,6 +1,7 @@
+import { StoryData } from "../data.js";
 import { bindAssets, unbindAssets } from "../../data/assets.js";
 import { Audio } from "../../engine/audio.js";
-import { ShaderLib } from "../../engine/glsl.js";
+import { ObjectResources } from "../../engine/objects.js";
 import { trackGL } from "../../engine/gltrack.js";
 import { PlayerLoop } from "../../engine/loop.js";
 import { Transform } from "../../engine/math.js";
@@ -15,19 +16,19 @@ import { AdvFieldRendererManager, AdvQuality } from "../field.js";
 import { ADV_PLAYBACK_MODE, STORY_FRAME_RATE, StoryCommandError, createStoryContext } from "../interfaces.js";
 import { storyModels } from "../models.js";
 import { StoryCharacters } from "../player-core.js";
-import { STORY_LANGUAGES, storyLines } from "../params.js";
+import { storyLines } from "../params.js";
 import { speakerName } from "../commands/talk.js";
 import { countedText, shownText } from "../ui-ruby.js";
 import { removeTagsWithRuby } from "../ui-talk.js";
 import { SilentAudio } from "../silent-audio.js";
 import { SIMPLE_ADVANCE, SIMPLE_COMPLETE } from "./define.js";
 import { SimpleHomeHost } from "./home/host.js";
-import { spotMainCamera } from "./home/post.js";
 import { SIMPLE_OWN_COMMANDS, SIMPLE_SHARED_COMMANDS, SimpleAdvPlayer } from "./player.js";
 import { CameraTargetRenderer, SimpleCaptureRenderer, cameraTargetDesc } from "./render.js";
 import { SimpleCanvas, SimpleUIDoc, runtimeNodeRecord, setActive } from "./ui.js";
 import { SIMPLE_UNIMPLEMENTED, simpleUnsupportedCommands, validateSimpleEpisode } from "./validator.js";
 import { SimpleAdvView, SimpleTalkWindow } from "./view.js";
+import { hostUIRoots } from "./objects.js";
 
 // SimpleStorySession: an Overlay episode (MasterAdv._playbackMode 1) as the game plays it: SimpleAdvPlayer inside the
 // screen that opens it. Same interface as StorySession (create, step, render, play, tap, dispose, line state), so the
@@ -55,8 +56,6 @@ const REFERENCE = { x: 1920, y: 1080 };     // the host widgets' CanvasScaler re
 // 2 the game's validator refused the episode and nothing was shown
 export const SIMPLE_END_REASON = Object.freeze({ completed: 0, stopped: 1, invalid: 2 });
 
-const dirname = (p) => { const i = p.lastIndexOf("/"); return i < 0 ? "" : p.slice(0, i); };
-
 // the texts the simple window shows: Talk lines and their speaker names
 export const simpleTexts = (episode, player, masterIds, localize) => {
   const p = { ctx: { settings: { player, masterIds }, localize } }, out = new Set();
@@ -77,14 +76,14 @@ export class SimpleStorySession {
 
   // an Overlay episode: the simple player plays it
   static isSimpleStory(store) {
-    const story = store.json("story.json"), episode = store.json(story.episode);
+    const { episode } = new StoryData(store);
     return (episode.master ? episode.master._playbackMode || 0 : 0) === ADV_PLAYBACK_MODE.Overlay;
   }
 
   // the commands the simple player runs for the episode, and the episode's refusal by the game's validator
   static requirements(store) {
-    const story = store.json("story.json"), episode = store.json(story.episode), scene = store.json(story.scene);
-    const v = validateSimpleEpisode(episode, scene.settings.playerSettings, 0);
+    const data = new StoryData(store), episode = data.episode;
+    const v = validateSimpleEpisode(episode, data.playerSettings, 0);
     const run = new Set([...SIMPLE_SHARED_COMMANDS, ...SIMPLE_OWN_COMMANDS]);
     const commands = [...new Set(episode.commands.filter((c) => !c.IgnoreData).map((c) => c.cmd))];
     return { commands: commands.filter((c) => run.has(c)), skipped: commands.filter((c) => !run.has(c)),
@@ -103,22 +102,20 @@ export class SimpleStorySession {
   async _load(gl, store, opts) {
     if (!store) throw new Error("SimpleStorySession: an AssetStore is required");
     this.gl = gl || null; this.assets = store; this.opts = opts;
-    const story = this.story = store.json("story.json");
-    const episode = this.episode = store.json(story.episode);
-    const scene = store.json(story.scene);
-    const P = scene.settings.playerSettings;
+    const data = this.data = new StoryData(store);
+    const story = this.story = data.story, episode = this.episode = data.episode;
+    const P = data.playerSettings;
     const what = `story ${episode.advId ?? story.advId}`;
     // refused before loading (validator.js SIMPLE_UNIMPLEMENTED)
     const lacking = episode.commands.find((c) => !c.IgnoreData && SIMPLE_UNIMPLEMENTED.includes(c.cmd));
     if (lacking) throw new StoryCommandError(`${what}: row ${lacking.i}: ${lacking.cmd} on a character slot is not provided by the simple player`);
-    const host = this.host = store.has("host/host.json") ? store.json("host/host.json") : null;
+    const host = this.host = data.host;
     this.hostKind = host ? host.kind : "none";
-    if (!store.has("ui/simple/ui.json")) throw new StoryCommandError(`${what}: the simple talk window (ui/simple/ui.json) is not in the story`);
-    const langDoc = store.has("ui/languages.json") ? store.json("ui/languages.json") : null;
-    const info = store.info || {};
-    const lang = this.lang = opts.lang || info.loadedLanguage || info.language || (langDoc && langDoc.language) || "ja";
-    if (langDoc && langDoc.language !== lang) throw new Error(`${what}: the loaded language is ${langDoc.language}, not ${lang}`);
-    const field = langDoc ? langDoc.field : STORY_LANGUAGES[lang];
+    if (!data.simpleui) throw new StoryCommandError(`${what}: the simple UI product is not in the story`);
+    const langDoc = data.simpleui.language;
+    const lang = this.lang = opts.lang || data.language;
+    if (data.language !== lang) throw new Error(`${what}: the loaded language is ${data.language}, not ${lang}`);
+    const field = langDoc.field;
     if (!field) throw new Error(`${what}: unknown language ${lang}`);
     const localize = (id) => {
       const r = episode.text[id];
@@ -129,12 +126,14 @@ export class SimpleStorySession {
 
     // UI documents first: the texts are checked before anything heavy loads
     const loop = this.loop = new PlayerLoop(STORY_FRAME_RATE);
-    const simpleDoc = store.json("ui/simple/ui.json");
-    const simpleFonts = store.has("ui/simple/fonts.json") ? store.json("ui/simple/fonts.json") : null;
-    const ui = this.ui = new SimpleUIDoc(gl, loop, simpleDoc, { assets: store, dir: "ui/simple", fonts: simpleFonts, language: langDoc });
-    const hostUi = this.hostUi = host && host.ui
-      ? new SimpleUIDoc(gl, loop, store.json(host.ui), { assets: store, dir: dirname(host.ui) }) : null;
-    this._checkTexts(simpleTexts(episode, P, scene.settings.masterIdSettings, localize), what);
+    const simpleDoc = data.simpleui;
+    const objects = this.objects = new ObjectResources(store, { ...data.resourceOptions(), gl });
+    const roots = [{ id: simpleDoc.talkWindow }];
+    if (story.host?.talk === "area") roots.push({ id: simpleDoc.systemMessage });
+    const ui = this.ui = new SimpleUIDoc(gl, loop, simpleDoc, { objects, roots, data, fonts: data.fonts, language: langDoc });
+    const hostUi = this.hostUi = host
+      ? new SimpleUIDoc(gl, loop, host, { objects, roots: hostUIRoots(host, objects) }) : null;
+    this._checkTexts(simpleTexts(episode, P, data.masterIds, localize), what);
 
     await cubismCore();
     const motionSync = await motionSyncCore().catch(() => null);
@@ -146,8 +145,8 @@ export class SimpleStorySession {
     // the UI tween runner (DOTweenComponent) and the host screen's canvases
     const tweens = this.tweens = { active: new Set() };
     this._buildCanvases(host, hostUi, ui, what);
-    const view = this.view = new SimpleAdvView(this.overlayRoot, host ? host.layoutRoot : null,
-                                               { tweens, dotween: simpleDoc.dotween });
+    const view = this.view = new SimpleAdvView(this.overlayRoot, host?.layoutRoot?.fields,
+                                               { tweens, dotween: ui.dotween });
     for (const s of view.slots) s.image.doc = ui;                       // the RawImage: UI/Default of the window doc
     const window = this.window = new SimpleTalkWindow(ui, TALK_WINDOW, { loop, tweens, language: langDoc });
 
@@ -155,10 +154,9 @@ export class SimpleStorySession {
     const manager = new Transform("AdvManager");
     const pool = new Transform("Pool", manager);
     const characters = this.characters = new StoryCharacters();
-    const storyLib = gl ? new ShaderLib(gl, "shaders", store) : null;     // the story's shaders (URP post)
     const renderer = this.renderer = gl ? new SimpleCaptureRenderer(gl, loop, { assets: store }) : null;
     // each character's model and the shaders it draws with (models.js)
-    const modelOf = storyModels(gl, store, story, what);
+    const modelOf = storyModels(gl, data);
     for (const c of episode.commands) {
       if (c.cmd !== "Character" || c.IgnoreData) continue;
       if (characters.has(c.TargetName, c.TargetAssetIndex || 0)) continue;
@@ -169,7 +167,7 @@ export class SimpleStorySession {
       if (renderer) renderer.addCharacter(ch, { lib, model });
     }
     // one CameraTargetRenderer per slot under the runtime parent (the host manager's transform)
-    const desc = cameraTargetDesc(host);
+    const desc = cameraTargetDesc(host, objects);
     this.cameraTargets = view.slots.map((s) => {
       const crt = new CameraTargetRenderer(s.index, manager, desc);
       crt.layer = CAMERA_LAYER_BASE + LAYERS.indexOf(s.def.layer);
@@ -177,29 +175,23 @@ export class SimpleStorySession {
     });
 
     // audio
-    const resolve = Audio.episodeResolver(episode);
+    const resolve = Audio.episodeResolver(episode, data);
     // a story without its sound files (story.json `audio` empty) plays no sound, with the voices off as in the game
     // without voice data (as StorySession)
-    const hasSounds = !!story.audio && Object.keys(story.audio).length > 0;
+    const hasSounds = Object.keys(data.parts.sounds || {}).length > 0;
     this.hasSounds = hasSounds;
     const webAudio = hasSounds && opts.sound !== false && typeof globalThis.AudioContext === "function";
-    const audio = this.audio = opts.audio ? opts.audio(resolve, loop, { assets: store })
-      : webAudio ? new Audio(resolve, loop, { context: opts.audioContext || null, assets: store })
-        : new SilentAudio(resolve, loop, { assets: store, sounds: hasSounds });
+    const audioOptions = { assets: store };
+    const audio = this.audio = opts.audio ? opts.audio(resolve, loop, audioOptions)
+      : webAudio ? new Audio(resolve, loop, { context: opts.audioContext || null, ...audioOptions })
+        : new SilentAudio(resolve, loop, { ...audioOptions, sounds: hasSounds });
     await audio.preload(Object.keys(episode.sounds).map(Number));
 
     // the home spot scene: the main camera with the Spot scene camera's info (post.js spotMainCamera) and its post chain
     if (this.hostKind === "home") {
-      const camNode = scene.cameraManager.nodes.find((n) => n.path === "CameraManager/MainCamera");
-      const cam = camNode ? camNode.components.find((c) => c.type === "Camera") : null;
-      if (!cam) throw new Error(`${what}: scene.json has no CameraManager/MainCamera camera`);
-      const data = camNode.components.find((c) => c.class === "UniversalAdditionalCameraData");
-      const root = host.home.sceneRoot || {};
-      this.home = await SimpleHomeHost.create(gl, store, loop, host,
-        { camera: spotMainCamera(cam, data, root.sceneCamera || null),
-          graphics: scene.player, quality: quality.level, spine: opts.spine,
-          post: { lib: storyLib, textures: scene.postTextures, filmGrain: opts.filmGrain ?? 0,
-                  screenScale: (w) => quality.screenScale(w) } });
+      this.home = await SimpleHomeHost.create(gl, store, loop, data,
+        { objects, quality: quality.level, spine: opts.spine,
+          post: { lib: objects.lib, filmGrain: opts.filmGrain ?? 0, screenScale: (w) => quality.screenScale(w) } });
       this.missing.push(...this.home.missing);
     }
     if (renderer) await renderer.load();
@@ -212,8 +204,8 @@ export class SimpleStorySession {
       loop, camera: null, field: null, background: { brightness: 1, originalColor: { r: 1, g: 1, b: 1, a: 1 },
                                                      color: { r: 1, g: 1, b: 1, a: 1 }, colorTween: null },
       fieldRenderer: new AdvFieldRendererManager(loop, quality), volume: null, characters, stages: new Map(),
-      ui: window, audio, quality, settings: { player: P, masterIds: scene.settings.masterIdSettings }, localize, lang,
-      playbackMode: ADV_PLAYBACK_MODE.Overlay, titleTextId: 0, episode, story, assets: store, renderer: null, gl: this.gl });
+      ui: window, audio, quality, settings: { player: P, masterIds: data.masterIds }, localize, lang,
+      playbackMode: ADV_PLAYBACK_MODE.Overlay, titleTextId: 0, episode, story, data, objects, assets: store, renderer: null, gl: this.gl });
     this.lines = storyLines(episode);
     const line = Math.max(0, Math.min(opts.line || 0, Math.max(0, this.lines.length - 1)));
     const request = this.hostKind === "afterlive"
@@ -269,17 +261,17 @@ export class SimpleStorySession {
     if (hostUi) {
       // root canvases in sorting order; UISpotLetterbox is not drawn: SpotLetterboxBands sizes its bands for screens
       // wider than 13:6 at runtime (not reproduced; the page is expected at 13:6 or narrower)
-      const roots = hostUi.roots.filter((r) => r.rec.canvasScaler && r.name !== "UISpotLetterbox");
-      roots.sort((a, b) => ((a.rec.canvas || {}).m_SortingOrder || 0) - ((b.rec.canvas || {}).m_SortingOrder || 0));
+      const roots = hostUi.roots.filter((r) => r.fields("CanvasScaler") && r.name !== "UISpotLetterbox");
+      roots.sort((a, b) => (a.fields("Canvas")?.m_SortingOrder || 0) - (b.fields("Canvas")?.m_SortingOrder || 0));
       for (const n of hostUi.nodes.values())                            // AspectRatioFitter components
-        if (n.rec.aspectRatioFitter && n.rec.aspectRatioFitter.m_Enabled) n.fitter = n.rec.aspectRatioFitter;
+        if (n.fields("AspectRatioFitter")?.m_Enabled) n.fitter = n.fields("AspectRatioFitter");
       for (const root of roots) {
         const fitters = [];
         const walk = (n) => { if (n.fitter) fitters.push(n); n.children.forEach(walk); };
         walk(root);
-        this.canvases.push({ name: root.name, canvas: new SimpleCanvas(root, root.rec.canvasScaler), root, fitters });
+        this.canvases.push({ name: root.name, canvas: new SimpleCanvas(root, root.fields("CanvasScaler")), root, fitters });
       }
-      this.overlayRoot = hostUi.node(host.overlayRoot);
+      this.overlayRoot = hostUi.node(host.overlayRoot.path);
       setActive(this.overlayRoot, false);
       if (host.kind === "afterlive") this._resultScreenState(hostUi, host.afterlive);
       this._applyOpenedSequences(hostUi, host.openedSequences);
@@ -307,22 +299,23 @@ export class SimpleStorySession {
 
   // the reward phase (ShowRewardPhase -> MusicResultViewPresenter.ShowReward): the reward panel shown
   _resultScreenState(doc, info) {
-    if (info && info.rewardPanel) setActive(doc.node(info.rewardPanel), true);
+    if (info?.rewardPanel) setActive(doc.node(info.rewardPanel.path), true);
+    if (info?.backgroundImage) doc.node(info.backgroundImage.path).image.spriteObj = doc.sprite(info.backgroundSprite);
   }
 
   // The DOTweenSequences the screen played before any talk can start (the widgets' open / transition in, the reward
   // view's in): each event call SimpleAnimationTrigger.PlayAnimation(state) plays the target's Animator state, whose
   // clip has long ended when the talk starts (the talk follows the screen's opening), so its end values apply.
   _applyOpenedSequences(doc, paths) {
-    for (const path of paths || []) {
-      const seq = doc.node(path).rec.tweenSequence;
-      if (!seq) throw new UIError(`${path}: no DOTweenSequence record`);
-      for (const cmd of seq.list) {
-        for (const call of cmd.calls || []) {
-          if (call.method !== "PlayAnimation") throw new UIError(`${path}: sequence call ${call.method} not implemented`);
-          const target = doc.node(call.target);
-          if (!target.animator) throw new UIError(`${call.target}: no Animator for PlayAnimation(${call.string})`);
-          if (!target.animator.play(call.string)) continue;
+    for (const { path } of paths || []) {
+      const node = doc.node(path), seq = node.fields("DOTweenSequence");
+      if (!seq) throw new UIError(`${path}: no DOTweenSequence component`);
+      for (const cmd of seq._list) {
+        for (const call of cmd._tweenEvent?.m_PersistentCalls?.m_Calls || []) {
+          if (call.m_MethodName !== "PlayAnimation") throw new UIError(`${path}: sequence call ${call.m_MethodName} not implemented`);
+          const target = node.ref(call.m_Target), state = call.m_Arguments.m_StringArgument;
+          if (!target?.animator) throw new UIError(`${path}: no Animator for PlayAnimation(${state})`);
+          if (!target.animator.play(state)) continue;
           const st = target.animator.state;
           target.animator.update(st.clip ? st.clip.length + 1 : 0);
         }
@@ -366,7 +359,7 @@ export class SimpleStorySession {
   // The host's steps around SimpleAdvPlayer.Play (SpotManager.OnTalkCharacter / PlayAreaTalkAsync,
   // LiveResultDisplayPresenter.PlaySimpleAdvResult)
   async _hostPlay() {
-    const home = this.home, h = this.host && this.host.home;
+    const home = this.home, h = this.story.host;
     if (home) {
       home.stopUiFadeAndShow();
       if (h.talk === "tap") {
@@ -391,22 +384,22 @@ export class SimpleStorySession {
   // _showAnimation.DOPlayAsync: its CustomEvent plays the widget Animator's state and the sequence lasts its
   // duration (the prefab's 2 s)
   async _showSystemMessage() {
-    const doc = this.ui, title = doc.doc.texts && doc.doc.texts.areaTitle;
+    const doc = this.ui, title = this.story.host?.title?.[this.lang];
     const root = doc.roots.find((r) => r.name === "UISystemMessageWidget");
     if (!root || typeof title !== "string") throw new StoryCommandError("the area talk's system message is not in the story data");
     if (!this.canvases.some((c) => c.root === root))
-      this.canvases.push({ name: root.name, canvas: new SimpleCanvas(root, root.rec.canvasScaler), root, fitters: [] });
+      this.canvases.push({ name: root.name, canvas: new SimpleCanvas(root, root.fields("CanvasScaler")), root, fitters: [] });
     const view = root.find("View"), trigger = root.find("ShowTrigger"), text = root.find("View/Message/UIText");
     text.storyText.setText(title);                                     // UISystemMessage: UIText.SetText
     setActive(root, true);
-    const seq = trigger.rec.tweenSequence;
-    if (!seq || seq.list.some((c) => c._commandType !== 1)) throw new UIError("system message: sequence outside the implemented subset");
+    const seq = trigger.fields("DOTweenSequence");
+    if (!seq || seq._list.some((c) => c._commandType !== 1)) throw new UIError("system message: sequence outside the implemented subset");
     // the CustomEvent's SimpleAnimationTrigger state: the controller's non-default state (its "Show" clip)
     const ctrl = view.animator ? view.animator.ctrl : null;
     const shows = ctrl ? ctrl.states.filter((st) => st !== ctrl.states[ctrl.defaultState]) : [];
     if (shows.length !== 1) throw new UIError("system message: the Animator's show state is not unique");
     const state = shows[0].name;
-    const duration = seq.list.reduce((a, c) => a + (c._duration > 0 ? c._duration : 0), 0);
+    const duration = seq._list.reduce((a, c) => a + (c._duration > 0 ? c._duration : 0), 0);
     const t = new UITween(this.tweens, { duration, at0: [() => { if (view.activeInHierarchy && view.animator) view.animator.play(state); }] });
     trigger.sequence = t;
     await t.promise;
diff --git a/src/story/simple/ui.js b/src/story/simple/ui.js
index 57cbff2..143bb85 100644
--- a/src/story/simple/ui.js
+++ b/src/story/simple/ui.js
@@ -1,14 +1,14 @@
-import { AnimClip, Animator } from "../../engine/anim.js";
-import { F, join } from "../../engine/core.js";
-import { ShaderLib } from "../../engine/glsl.js";
+import { Animator } from "../../engine/anim.js";
 import { GLTex } from "../../engine/texture.js";
-import { UI_CLIP_TARGET, UIDraw, UIError, UIImage, UILayout, UIMesh, UINode, UISprite, uiCanvasSize, uiColor32 } from "../../engine/ugui.js";
+import { UIDraw, UIError, UIImage, UILayout, UIMesh, UINode, UISprite, uiCanvasSize, uiColor32 } from "../../engine/ugui.js";
 import { TMPText, UIGradientMod } from "../../engine/uitext.js";
+import { uiTree, uiTextBinding } from "../ui-objects.js";
+import { TransformNode, bindCanvasProperty } from "../features/canvas.js";
 import { StoryFontAssets } from "../ui-fonts.js";
 import { StoryText } from "../ui-ruby.js";
 
-// The uGUI documents of the simple player: the simple talk window (UISimpleAdvTalkWindow, ui/simple/ui.json with its
-// fonts) and the host screen's widgets (host/ui/ui.json), in the record format the story UI data uses. A document
+// The uGUI products of the simple player: the simple talk window (UISimpleAdvTalkWindow), its fonts,
+// and the host screen's widgets. A document
 // builds its RectTransform nodes (engine/ugui.js), images, gradients, TMP texts (engine/uitext.js) with their text
 // components (`storyText`: ui-ruby.js StoryText over the font data's binding, as the story UI), animators and layout
 // groups; SimpleCanvas lays out and draws node trees that mix nodes of several documents (the view reparents the talk
@@ -20,69 +20,22 @@ const LANGUAGE_ENGLISH = 1;                  // Fwk.Localization.LanguageMode.En
 const LANGUAGE_KOREAN = 4;                   // Fwk.Localization.LanguageMode.Korean
 const IDENTITY_Q = { x: 0, y: 0, z: 0, w: 1 };
 
-// ------------------------------------------------------------------------------------------------ animation
-// An Animator clip of the host UI data. Curves are keyed "<path>:<Class>.<property>", the path relative to the
-// Animator's node ("" or no path: the node itself; "#<hash>": a path the game data does not resolve, which the
-// Animator binds to nothing), each {keys: [[time, c0, c1, c2, c3]]} (streamed Hermite segments), {discrete:
-// [[time, value]]} (a step curve: the value of the last key at or before the time) or {constant}. A discrete
-// Image.m_Sprite value indexes `pptrCurveMapping` (sprite names).
-export class SimpleUIClip extends AnimClip {
-  constructor(clip) {
-    if (clip.startTime) throw new UIError(`clip ${clip.name}: start time ${clip.startTime}`);
-    if (clip.events && clip.events.length) throw new UIError(`clip ${clip.name}: animation events not implemented`);
-    const curves = Object.entries(clip.curves).map(([key, c]) => {
-      const i = key.lastIndexOf(":"), path = i < 0 ? "" : key.slice(0, i), prop = key.slice(i + 1);
-      const cut = prop.indexOf(".");
-      const binding = { path, cls: prop.slice(0, cut), attr: prop.slice(cut + 1), prop };
-      if ("constant" in c) return { binding, constant: F(c.constant) };
-      const t = [], k = [];
-      if (c.discrete) for (const [time, v] of c.discrete) { t.push(F(time)); k.push(0, 0, 0, F(v)); }
-      else if (c.keys) for (const [time, c0, c1, c2, c3] of c.keys) { t.push(F(time)); k.push(F(c0), F(c1), F(c2), F(c3)); }
-      else throw new UIError(`clip ${clip.name}: curve ${key} in a form not implemented (${Object.keys(c).join(", ")})`);
-      return { binding, t, k };
-    });
-    super({ name: clip.name, length: clip.stopTime, loopTime: clip.loopTime, curves, events: [] });
-    this.pptr = clip.pptrCurveMapping || [];
-  }
-}
-
-// The properties a host UI clip drives besides UI_CLIP_TARGET: Image.m_Sprite (a PPtr curve of the playing state's
-// clip) and GameObject.m_IsActive
-const SIMPLE_CLIP_TARGET = {
-  "Image.m_Sprite": (n, v, anim) => {
-    const name = anim.state.clip.pptr[Math.round(v)], sp = name ? n.doc.sprites.get(name) : null;
-    if (!n.image) throw new UIError(`${n.path}: clip drives the sprite of a node without an Image`);
-    if (!sp) throw new UIError(`${n.path}: clip sprite ${name ?? v} not in the data`);
-    n.image.spriteObj = sp;
-  },
-  "GameObject.m_IsActive": (n, v) => { setActive(n, v !== 0); },
-};
-
-// The Animator of a host UI node: one layer, no transitions or parameters, Write Defaults off (the prefab
-// controllers), each state playing its clip; curve bindings resolve against the node's subtree. Bindings to a
-// "#<hash>" path or a node outside the exported tree bind to nothing (Unity skips a binding whose object is
-// missing); the latter are listed in doc.unbound.
+// The native AnimatorController of a host UI prefab, with object references for discrete sprite curves.
 export class SimpleUIAnimator extends Animator {
-  constructor(node, ctrl, clips, doc) {
-    const states = ctrl.states.map((s) => {
-      const key = `${ctrl.name}/${s.clip}`;
-      const clip = s.clip ? clips[key] || null : null;
-      if (s.clip && !clip) throw new UIError(`${node.path}: clip ${key} not in the data`);
-      if (s.cycleOffset) throw new UIError(`${ctrl.name}.${s.name}: cycle offset not implemented`);
-      return { name: s.name, speed: s.speed ?? 1, clip, writeDefaults: false, transitions: [] };
-    });
-    const defaultState = states.findIndex((s) => s.name === ctrl.defaultState);
-    if (defaultState < 0) throw new UIError(`${ctrl.name}: no default state ${ctrl.defaultState}`);
-    const self = {};
-    super({ name: ctrl.name, states, defaultState, anyState: [], parameters: new Map() }, (b) => {
-      if (b.path.startsWith("#")) return null;
+  constructor(node, ctrl, doc) {
+    super(ctrl, (b) => {
+      if (b.path === null || b.path.startsWith("#")) return null;
       const target = b.path ? doc.nodes.get(`${node.path}/${b.path}`) : node;
       if (!target) { doc.unbound.push(`${ctrl.name}: ${b.path}`); return null; }
-      const ui = UI_CLIP_TARGET[b.prop], own = SIMPLE_CLIP_TARGET[b.prop];
-      if (!ui && !own) throw new UIError(`${ctrl.name}: clip property ${b.prop} not implemented`);
-      return { set: ui ? (v) => ui(target, v) : (v) => own(target, v, self.animator) };
+      if (b.cls === "Image" && b.attr === "m_Sprite") {
+        if (!target.image) throw new UIError(`${target.path}: animated sprite without an Image`);
+        return { get: () => target.image.spriteObj?.name || null,
+          set: (ref) => { target.image.spriteObj = doc.sprite(ref); } };
+      }
+      if (b.cls === "GameObject" && b.attr === "m_IsActive")
+        return { get: () => target.activeSelf ? 1 : 0, set: (v) => setActive(target, v !== 0) };
+      return bindCanvasProperty(node, b);
     });
-    self.animator = this;
     this.node = node;
   }
 
@@ -108,72 +61,86 @@ export const runtimeNodeRecord = (path, name, { min = { x: 0, y: 0 }, max = { x:
 });
 
 export class SimpleUIDoc {
-  // gl may be null (layout and timing only). doc = the ui.json record document; fonts = its fonts.json (texts need
-  // it); language = the story's ui/languages.json; assets = the story's AssetStore; dir = the document's directory
-  constructor(gl, loop, doc, { assets, dir, fonts = null, language = null }) {
-    this.gl = gl; this.loop = loop; this.doc = doc; this.assets = assets; this.dir = dir;
-    this.fonts = fonts; this.language = language;
-    const byPath = new Map(), roots = [];
-    for (const rec of doc.nodes) {                  // hierarchy order (parents first)
-      const i = rec.path.lastIndexOf("/");
-      const parent = i < 0 ? null : byPath.get(rec.path.slice(0, i)) || null;
-      if (i >= 0 && !parent) throw new UIError(`ui node ${rec.path} has no parent in the data`);
-      const n = new UINode(rec, parent);
-      n.doc = this;
-      byPath.set(rec.path, n);
-      if (!parent) roots.push(n);
+  // gl may be null (layout and timing only). roots select prefab subtrees; fonts supplies object-id text bindings.
+  constructor(gl, loop, doc, { objects, roots, data = null, fonts = null, language = null }) {
+    this.gl = gl; this.loop = loop; this.doc = doc; this.objects = objects; this.assets = objects.assets;
+    this.dir = data?.fontDir || ""; this.fonts = fonts; this.language = language;
+    this.dotween = objects.mono(doc.dotween || doc.settings.dotween);
+    const byPath = this.nodes = new Map();
+    const Node = class {
+      constructor(rec, parent) { return rec.rect ? new UINode(rec, parent) : new TransformNode(rec, parent); }
+    };
+    this.roots = roots.map(({ id, include, texts = true }) => {
+      const root = uiTree(objects, id, { nodes: byPath, Node, include });
+      for (const n of byPath.values()) if (n.prefabId === id) { n.doc = this; n.bindText = texts; }
+      return root;
+    });
+    this.sprites = new Map(); this.textures = new Set();
+    this.uiMaterials = new Map([[DEFAULT_UI_MATERIAL, { shader: "UI/Default", keywords: [], floats: {}, colors: {} }]]);
+    this._fonts = fonts ? new StoryFontAssets(fonts, doc, language) : null;
+    this.animators = []; this.unbound = [];
+    for (const n of byPath.values()) this._setupNode(n);
+    for (const n of byPath.values()) this._setupAnimator(n);
+  }
+
+  sprite(ref) {
+    const id = this.objects.id(ref, "Sprite");
+    if (id === null) return null;
+    if (!this.sprites.has(id)) {
+      const s = this.objects.sprite(id);
+      this.sprites.set(id, new UISprite(id, { ...s, pixelsPerUnit: s.pixelsToUnits }, s.texture));
+      this.textures.add(s.texture.id);
     }
-    this.nodes = byPath; this.roots = roots;
-    this.sprites = new Map(Object.entries(doc.sprites || {}).map(([name, s]) => {
-      const t = doc.textures[s.texture];
-      if (!t) throw new UIError(`sprite ${name}: texture ${s.texture} not in the data`);
-      return [name, new UISprite(name, s, t)];
-    }));
-    this._fonts = this.fonts ? new StoryFontAssets(this.fonts, doc, this.language) : null;   // open fonts: the game's line metrics
-    const clips = Object.fromEntries(Object.entries(doc.clips || {}).map(([k, c]) => [k, new SimpleUIClip(c)]));
-    this.animators = [];
-    this.unbound = [];
-    for (const n of byPath.values()) this._setupNode(n, clips);
+    return this.sprites.get(id);
   }
 
-  _setupNode(n, clips) {
-    const r = n.rec, doc = this.doc;
-    if (r.image) {
-      const sp = r.image.sprite;
-      if (sp && !this.sprites.has(sp)) throw new UIError(`${n.path}: sprite ${sp} not in the data`);
-      n.image = { ...r.image, spriteObj: sp ? this.sprites.get(sp) : null, material: r.image.material || DEFAULT_UI_MATERIAL };
-      if (!doc.materials[n.image.material]) throw new UIError(`${n.path}: material ${n.image.material} not in the data`);
+  uiMaterial(ref) {
+    const id = this.objects.id(ref, "Material");
+    if (id === null) return DEFAULT_UI_MATERIAL;
+    if (!this.uiMaterials.has(id)) this.uiMaterials.set(id, this.objects.material(id));
+    return id;
+  }
+
+  _setupNode(n) {
+    const g = n.fields("Image"), raw = n.fields("RawImage");
+    if (g) n.image = { ...g, spriteObj: this.sprite(g.m_Sprite), material: this.uiMaterial(g.m_Material) };
+    if (raw) {
+      const textureName = this.objects.id(raw.m_Texture, "Texture2D");
+      if (textureName) this.textures.add(textureName);
+      n.rawImage = { ...raw, material: this.uiMaterial(raw.m_Material), textureName, texture: null };
     }
-    if (r.rawImage) n.rawImage = { ...r.rawImage, material: r.rawImage.material || DEFAULT_UI_MATERIAL,
-                                   textureName: r.rawImage.texture || null, texture: null };
-    if (r.gradient && r.gradient.enabled) n.gradient = r.gradient;
-    if (r.textStyle) {
-      if (!this.fonts) throw new UIError(`${n.path}: a text node without font data`);
-      let t = this.fonts.texts[n.path];
-      if (!t) throw new UIError(`${n.path}: no text binding in the font data`);
-      const mode = this.language ? this.language.mode : 0;
-      // LocalizeKoreanAdjust.Apply: in the Korean language mode ForceNormal (1) clears and ForceBold (2) sets Bold
-      const ko = t.localizeKoreanAdjust;
-      if (ko && ko.m_Enabled && mode === LANGUAGE_KOREAN && (ko._koreanFontStyle === 1 || ko._koreanFontStyle === 2))
+    const gradient = n.fields("UIGradientImage");
+    if (gradient?.m_Enabled) n.gradient = { gradient: gradient._gradient, angleDeg: gradient._angleDeg,
+      splitAtKeysWhenAxisAligned: gradient._splitAtKeysWhenAxisAligned, blendMode: gradient._blendMode };
+    let t = n.bindText && this.fonts ? uiTextBinding(n, this.fonts) : null;
+    if (t) {
+      const mode = this.language?.mode || 0, ko = t.localizeKoreanAdjust;
+      if (ko?.m_Enabled && mode === LANGUAGE_KOREAN && (ko._koreanFontStyle === 1 || ko._koreanFontStyle === 2))
         t = { ...t, m_fontStyle: ko._koreanFontStyle === 2 ? t.m_fontStyle | 1 : t.m_fontStyle & ~1 };
-      n.text = new TMPText(this, n, t);
-      n.text.enabled = !!t.enabled;
-      // LocalizeText.OnFontChanged, English only: word wrapping on unless the object's name contains "nowrap"
+      n.text = new TMPText(this, n, t); n.text.enabled = !!t.enabled;
       if (mode === LANGUAGE_ENGLISH && !n.name.toLowerCase().includes("nowrap")) n.text.setWrapping(1);
       n.storyText = new StoryText(n.text, t);
     }
-    if (r.animator) {
-      const a = r.animator, ctrl = (doc.controllers || {})[a.controller];
-      if (!ctrl) throw new UIError(`${n.path}: controller ${a.controller} not in the data`);
-      if (a.updateMode !== 0 || !a.enabled || a.keepStateOnDisable)
+    for (const cls of ["HorizontalLayoutGroup", "VerticalLayoutGroup"]) {
+      const layout = n.fields(cls);
+      if (layout?.m_Enabled) n.layoutGroup = { ...layout, class: cls };
+    }
+    const fitter = n.fields("ContentSizeFitter"), element = n.fields("LayoutElement");
+    if (fitter?.m_Enabled) n.contentSizeFitter = fitter;
+    if (element?.m_Enabled) n.layoutElement = element;
+    if (n.fields("Outline")?.m_Enabled) throw new UIError(`${n.path}: enabled Outline effect not implemented`);
+  }
+
+  _setupAnimator(n) {
+    const a = n.fields("Animator");
+    if (a?.m_Controller) {
+      if (a.m_UpdateMode !== 0 || !a.m_Enabled || a.m_KeepAnimatorStateOnDisable)
         throw new UIError(`${n.path}: animator settings outside the prefab values`);
-      n.animator = new SimpleUIAnimator(n, ctrl, clips, this);
-      this.animators.push(n.animator);
+      const ctrl = this.objects.controller(a.m_Controller, n.prefabId, n.sourcePath);
+      n.animator = new SimpleUIAnimator(n, ctrl, this); this.animators.push(n.animator);
+      for (const clip of ctrl.clipList) for (const curve of clip.curves)
+        if (curve.binding.pptr) for (const ref of curve.objects) this.sprite(ref);
     }
-    if (r.layoutGroup && r.layoutGroup.m_Enabled) n.layoutGroup = r.layoutGroup;
-    if (r.contentSizeFitter && r.contentSizeFitter.m_Enabled) n.contentSizeFitter = r.contentSizeFitter;
-    if (r.layoutElement && r.layoutElement.m_Enabled) n.layoutElement = r.layoutElement;
-    if (r.outline && r.outline.enabled) throw new UIError(`${n.path}: enabled Outline effect not implemented`);
   }
 
   node(path) {
@@ -195,31 +162,24 @@ export class SimpleUIDoc {
   async load() {
     const gl = this.gl;
     if (!gl) return;
-    const assets = this.assets || undefined;
-    this.lib = new ShaderLib(gl, join(this.dir, this.doc.shaders.index.replace(/\/shaders\.json$/, "")), assets);
-    this.fontLib = this.fonts && this.fonts.shaders
-      ? new ShaderLib(gl, join(this.dir, this.fonts.shaders.index.replace(/\/shaders\.json$/, "")), assets) : this.lib;
+    this.lib = this.objects.lib;
     this.solid = { white: GLTex.solid(gl, [255, 255, 255, 255], "white"), black: GLTex.solid(gl, [0, 0, 0, 255], "black"),
-                   gray: GLTex.solid(gl, [128, 128, 128, 255], "gray"), bump: GLTex.solid(gl, [128, 128, 255, 255], "bump") };
+      gray: GLTex.solid(gl, [128, 128, 128, 255], "gray"), bump: GLTex.solid(gl, [128, 128, 255, 255], "bump") };
     this.tex = {};
-    const texs = [...Object.entries(this.doc.textures || {}), ...Object.entries(this.fonts ? this.fonts.textures : {})];
-    for (const [name, desc] of texs) {
-      if (this.tex[name]) throw new UIError(`texture name ${name} used twice`);
-      this.tex[name] = await GLTex.load(gl, this.dir, desc, assets);
-    }
-    if (this._fonts) for (const g of this._fonts.browserFonts().values()) this.tex[g.page] = g.texture(gl);   // browser fonts' pages
+    for (const id of this.textures) this.tex[id] = await this.objects.texture(id);
+    for (const [name, desc] of Object.entries(this.fonts?.textures || {}))
+      this.tex[name] = await GLTex.load(gl, this.dir, desc, this.assets);
+    if (this._fonts) for (const g of this._fonts.browserFonts().values()) this.tex[g.page] = g.texture(gl);
     this.materials = {};
-    const add = (lib, mats, keywords) => {
-      for (const [name, m] of Object.entries(mats || {})) {
-        const shader = m.shader.shader, defaults = lib.defaults(shader, this.solid);
-        const num = Object.fromEntries(Object.entries(defaults).filter(([, v]) => typeof v === "number"));
-        this.materials[name] = { lib, shader, keywords: (keywords || {})[name] || [], floats: { ...num, ...m.floats },
-                                 colors: m.colors || {}, defaults };
-        lib.program(shader, 0, this.materials[name].keywords);         // compile up front
-      }
+    const add = (name, m, shader, keywords) => {
+      const lib = this.lib, defaults = lib.defaults(shader, this.solid);
+      const num = Object.fromEntries(Object.entries(defaults).filter(([, v]) => typeof v === "number"));
+      this.materials[name] = { lib, shader, keywords, floats: { ...num, ...m.floats }, colors: m.colors || {}, defaults };
+      lib.program(shader, 0, keywords);
     };
-    add(this.lib, this.doc.materials, this.doc.materialKeywords);
-    if (this.fonts) add(this.fontLib, this.fonts.materials, this.fonts.materialKeywords);
+    for (const [id, m] of this.uiMaterials) add(id, m, m.shader, m.keywords || []);
+    if (this.fonts) for (const [name, m] of Object.entries(this.fonts.materials))
+      add(name, m, this.fonts.shaders[m.shader.shader], this.fonts.materialKeywords[name] || []);
     this.buf = { vao: gl.createVertexArray(), vbo: gl.createBuffer(), ibo: gl.createBuffer() };
   }
 
@@ -237,7 +197,7 @@ export class SimpleUIDoc {
     const img = n.image, sp = img.spriteObj;
     let mesh = UIImage.build(n, img, sp, refPPU);
     if (n.gradient) mesh = UIGradientMod.apply(mesh, n.gradient);
-    return { doc: this, node: n, kind: "image", material: img.material, texture: sp && this.tex ? this.tex[sp.texture.name] : null,
+    return { doc: this, node: n, kind: "image", material: img.material, texture: sp && this.tex ? this.tex[sp.texture.id] : null,
              verts: UIDraw.pack(mesh.verts, n, alpha), idx: Uint32Array.from(mesh.idx) };
   }
 
diff --git a/src/story/simple/view.js b/src/story/simple/view.js
index 3d52f28..9ff3b80 100644
--- a/src/story/simple/view.js
+++ b/src/story/simple/view.js
@@ -281,17 +281,17 @@ export class SimpleAdvView {
 // background, next indicator, auto or fast icon.
 export class SimpleTalkWindow {
   constructor(doc, rootPath, { loop, tweens, language }) {
-    const root = doc.node(rootPath), f = (rel) => root.find(rel);
-    if (!root.rec.talkWindow) throw new UIError(`${rootPath}: no UIAdvTalkWindow record`);
+    const root = doc.node(rootPath), tw = root.fields("UIAdvTalkWindow");
+    if (!tw) throw new UIError(`${rootPath}: no UIAdvTalkWindow component`);
     this.root = root;
     this.part = {
-      window: root, background: null, talkArea: f("TalkArea"), talkText: f("TalkArea/Content/TextWindow/TalkText"),
-      nextIndicator: null, autoIcon: null, fastIcon: null, speaker: f("TalkArea/Content/Speaker"),
-      speakerText: f("TalkArea/Content/Speaker/Back/SpeakerText"),
+      window: root, background: root.ref(tw._talkBackground), talkArea: root.ref(tw.TalkArea), talkText: root.ref(tw.TalkText),
+      nextIndicator: root.ref(tw._talkNextIndicator), autoIcon: root.ref(tw._autoIcon), fastIcon: root.ref(tw._fastIcon),
+      speaker: root.ref(tw._speakerNameObjects?.[0]), speakerText: root.ref(tw.SpeakerText),
     };
-    this.loop = loop; this.tweens = tweens; this.language = language; this.doc = { dotween: doc.doc.dotween };
+    this.loop = loop; this.tweens = tweens; this.language = language; this.dotween = doc.dotween;
     this.setActive = setActive;
-    this.talk = new StoryTalkWindow(this);
+    this.talk = new StoryTalkWindow(this, tw);
     this.speakerName = "";
     setActive(root, false);
   }
diff --git a/src/story/stage.js b/src/story/stage.js
index 34a2c9a..8d77e73 100644
--- a/src/story/stage.js
+++ b/src/story/stage.js
@@ -1,4 +1,3 @@
-import { Prefab } from "../engine/prefab.js";
 import { StoryCommandError } from "./interfaces.js";
 import { createStageParticleGroups, releaseStageParticleGroups } from "./features/effect.js";
 
@@ -8,17 +7,17 @@ import { createStageParticleGroups, releaseStageParticleGroups } from "./feature
 export const LIGHT_TYPE = { 0: "Spot", 1: "Directional", 2: "Point", 3: "Area" };
 
 export class AdvStageData {
-  constructor(exported) {
-    this.prefab = new Prefab(exported);
+  constructor(prefab, objects) {
+    this.prefab = prefab;
     const rootPath = this.prefab.root.name;
-    const s = this.prefab.component(rootPath, "AdvStage");
+    const s = this.prefab.fields(rootPath, "AdvStage");
     this.raw = s;
     this.name = rootPath;
     this.characterFieldPosition = s._characterFieldPosition;
     this.characterFieldScale = s._characterFieldScale;
     this.backgroundFieldPosition = s._backgroundFieldPosition;
     this.backgroundFieldScale = s._backgroundFieldScale;
-    this.backgroundSprite = s._backgroundSprite;
+    this.backgroundSprite = objects.sprite(s._backgroundSprite);
     this.backgroundColor = s._backgroundColor;
     this.fov = s._fov;
     this.initialCameraPosition = s._initialCameraPosition;
@@ -26,7 +25,7 @@ export class AdvStageData {
     this.focusDataSettingsKey = s._usingFocusDataSettingsKey;
     this.focusPoints = s._focusPointsCollection._entries.map((e) => e._focusPointPositions);
     this.shadow = {
-      texture: s._shadowTexture, uv: s._shadowTextureUv, intensity: s._shadowTextureIntensity,
+      texture: objects.id(s._shadowTexture, "Texture2D"), uv: s._shadowTextureUv, intensity: s._shadowTextureIntensity,
       amplitude: s._shadowTextureAmplitude, frequency: s._shadowTextureFrequency,
     };
     // a feature of the stage format this player does not draw: refused when the stage is loaded
@@ -35,11 +34,12 @@ export class AdvStageData {
     // the effects of each AdvParticleEffectGroup (built by initParticleGroups)
     this.particleGroups = this.particleEffectGroupCollection._groups.map(() => []);
     this.loop = null;
-    this.volumeProfiles = s._allVolumeProfileCollection._profiles;
+    this.volumeProfiles = s._allVolumeProfileCollection._profiles.map((ref) => objects.profile(ref));
     this.lightGroups = s._lightGroupCollection._groups.map((g) => g._lights.map((ref) => {
-      const light = this.prefab.component(ref.gameObject, "Light");
-      const urp = this.prefab.component(ref.gameObject, "UniversalAdditionalLightData");
-      return { path: ref.gameObject, transform: this.prefab.transform(ref.gameObject), light, urp,
+      const path = this.prefab.pathOf(ref);
+      const light = this.prefab.fields(path, "Light");
+      const urp = this.prefab.fields(path, "UniversalAdditionalLightData");
+      return { path, transform: this.prefab.transform(path), light, urp,
                type: LIGHT_TYPE[light.m_Type] };
     }));
     // AdvStage.Init -> AdvLightGroupCollection.Init: every light's GameObject inactive
@@ -63,21 +63,6 @@ export class AdvStageData {
     if (g) for (const l of g) this.lightActive.set(l.path, active);
   }
 
-  // A shared asset (e.g. a volume profile used by several stages) is exported in full once and by name elsewhere;
-  // resolves those names across the stages.
-  static resolveShared(stages) {
-    const profiles = new Map();
-    for (const st of stages) for (const p of st.volumeProfiles) if (p.components) profiles.set(p.name, p);
-    for (const st of stages) {
-      st.volumeProfiles = st.volumeProfiles.map((p) => {
-        if (p.components) return p;
-        const full = profiles.get(p.name);
-        if (!full) throw new Error(`stage ${st.name}: volume profile ${p.name} not exported`);
-        return full;
-      });
-    }
-  }
-
   showLights() { this._setLightGroupActive(this.currentLightGroup, true); }
   hideLights() { this._setLightGroupActive(this.currentLightGroup, false); }
 
@@ -100,7 +85,7 @@ export class AdvStageData {
   get hasParticleEffects() { return this.particleEffectGroupCollection._groups.some((g) => g._particleEffects.length > 0); }
 
   // AdvStage.Init -> AdvParticleEffectGroupCollection.Init: each group's effects built over the stage prefab and
-  // initialized (stopped, cleared, hidden). records: AnimRecords of the scene data file.
+  // initialized (stopped, cleared, hidden), with the shared ObjectResources.
   initParticleGroups(ctx, records) {
     this.loop = ctx.loop;
     if (!this.hasParticleEffects) return;
diff --git a/src/story/store.js b/src/story/store.js
new file mode 100644
index 0000000..cb4bfd5
--- /dev/null
+++ b/src/story/store.js
@@ -0,0 +1,111 @@
+import { AssetStore, PRODUCT_MANIFEST, decodeAsset } from "../data/assets.js";
+import { isProduct, mergeProductManifests, productDir } from "../data/products.js";
+import { ADV_PLAYBACK_MODE, StoryCommandError } from "./interfaces.js";
+import { StoryPlayerCore } from "./player-core.js";
+import { STORY_LANGUAGES } from "./params.js";
+import { simpleUnsupportedCommands } from "./simple/validator.js";
+import "./features/index.js";
+
+export const STORY_PRODUCT = "story";
+const SINGLE_PARTS = { scene: "story.scene", chat: "story.chat", crilips: "story.crilips" };
+const MAPPED_PARTS = { assets: "story.asset", models: "live2d.model", sounds: "story.sound", videos: "story.video",
+  host: "story.host", spots: "spot.files", rooms: "room.gltf" };
+const LANGUAGE_PARTS = { ui: "story.ui", fonts: "story.fonts", simpleui: "story.simpleui" };
+const here = () => globalThis.document?.baseURI || globalThis.location?.href;
+
+const cachedFetch = (fetch) => {
+  const requests = new Map();
+  return async (url, init) => {
+    const key = String(url);
+    if (!requests.has(key)) requests.set(key, (async () => {
+      const response = await fetch(url, init);
+      if (!response.ok) throw new Error(`${key}: HTTP ${response.status}`);
+      return new Uint8Array(await response.arrayBuffer());
+    })().catch((error) => { requests.delete(key); throw error; }));
+    return new Response(await requests.get(key));
+  };
+};
+
+// Read the index and episode before fetching dependent products, so unsupported commands fail early.
+export const fetchStoryProduct = async (url, { fetch = globalThis.fetch, signal = null, base = null,
+                                              decode = decodeAsset } = {}) => {
+  if (!url) throw new Error("no story manifest URL");
+  if (typeof fetch !== "function") throw new Error("no fetch function");
+  const href = new URL(String(url), here()).href;
+  const get = cachedFetch(fetch);
+  signal?.throwIfAborted();
+  const manifest = await (await get(href, signal ? { signal } : undefined)).json();
+  if (!isProduct(manifest, STORY_PRODUCT)) throw new Error(`${href}: not a story product (${PRODUCT_MANIFEST})`);
+  const root = base ? new URL(String(base), here()).href : new URL(manifest.root || "../", href).href;
+  const files = Object.fromEntries(["story.json", "episode.json"].map((name) => {
+    if (!manifest.files[name]) throw new Error(`${href}: missing ${name}`);
+    return [name, manifest.files[name]];
+  }));
+  const head = await AssetStore.fromManifest(href, { fetch: (u, init) => String(u) === href
+    ? Promise.resolve(new Response(JSON.stringify({ files, objects: {} }))) : get(u, init),
+    signal, base: root, decode });
+  const story = head.json("story.json"), episode = head.json("episode.json");
+  if (story?.format !== 1 || !story.parts || String(story.advId) !== manifest.subject || episode.advId !== story.advId)
+    throw new Error(`${href}: story index and episode do not match the product subject`);
+  const commands = StoryPlayerCore.requiredCommands(episode, { _initializeEpisodes: [], _finalizeEpisodes: [] });
+  const overlay = episode.master?._playbackMode === ADV_PLAYBACK_MODE.Overlay;
+  const unsupported = overlay ? simpleUnsupportedCommands(commands)
+    : commands.filter((name) => !StoryPlayerCore.supportedCommands().includes(name));
+  if (unsupported.length) throw new StoryCommandError(`story ${story.advId}: commands not supported by this player: ${unsupported.join(", ")}`);
+  return { url: href, manifest, root, story, episode, fetch: get };
+};
+
+// The product identities required for one language of a story index.
+export const storyPartRequests = (story, language) => {
+  const parts = story.parts, wanted = new Map();
+  const add = (path, product, subject = null) => {
+    productDir(path);
+    const existing = wanted.get(path);
+    if (existing && (existing.product !== product || existing.subject !== subject))
+      throw new Error(`${path}: conflicting story part identities`);
+    wanted.set(path, { product, subject });
+  };
+  for (const [part, product] of Object.entries(SINGLE_PARTS)) {
+    if (part === "scene" && !parts[part]) throw new Error("story index has no scene part");
+    if (parts[part]) add(parts[part], product, "default");
+  }
+  for (const [part, product] of Object.entries(MAPPED_PARTS))
+    for (const [subject, path] of Object.entries(parts[part] || {})) add(path, product, subject);
+  for (const [part, product] of Object.entries(LANGUAGE_PARTS)) {
+    if (part === "simpleui" && !parts[part]) continue;
+    const path = parts[part]?.[language];
+    if (typeof path !== "string") throw new Error(`story ${story.advId}: no ${part} for language ${language}`);
+    add(path, product, part === "fonts" ? `${story.advId}/${language}` : language);
+  }
+  return wanted;
+};
+
+// Each product's files live under its manifest directory; all object roles share one AssetStore table.
+export const loadStoryProducts = async (url, { lang = null, fetch = globalThis.fetch, signal = null,
+  base = null, decode = decodeAsset, concurrency, onProgress = null, head = null } = {}) => {
+  const first = head || await fetchStoryProduct(url, { fetch, signal, base, decode });
+  const language = lang || first.manifest.language;
+  if (!language) throw new Error("a story language is required (lang)");
+  const wanted = storyPartRequests(first.story, language);
+  const loaded = await Promise.all([...wanted].map(async ([path, identity]) => {
+    signal?.throwIfAborted();
+    const href = new URL(path, first.root).href;
+    const manifest = await (await first.fetch(href, signal ? { signal } : undefined)).json();
+    if (!isProduct(manifest, identity.product) || manifest.subject !== identity.subject)
+      throw new Error(`${href}: expected ${identity.product} product of ${identity.subject}`);
+    return [productDir(path), manifest];
+  }));
+  const dir = productDir(`stories/${first.story.advId}.json`);
+  const manifest = mergeProductManifests([[dir, first.manifest], ...loaded]);
+  manifest.loadedLanguage = language;
+  manifest.language = language;
+  manifest.languages = Object.fromEntries(Object.keys(first.story.parts.ui || {}).map((code) => [code, {}]));
+  manifest.advId = first.story.advId;
+  const titles = Object.fromEntries(Object.entries(STORY_LANGUAGES)
+    .filter(([, field]) => typeof first.episode.title?.[field] === "string" && first.episode.title[field])
+    .map(([code, field]) => [code, first.episode.title[field]]));
+  manifest.story = { advId: first.story.advId, playbackMode: first.episode.master?._playbackMode || 0, titles };
+  return AssetStore.fromManifest(first.url, { fetch: (u, init) => String(u) === first.url
+    ? Promise.resolve(new Response(JSON.stringify(manifest))) : first.fetch(u, init), signal, decode, concurrency,
+    onProgress, base: first.root });
+};
diff --git a/src/story/ui-chat.js b/src/story/ui-chat.js
index 4d97e63..f498412 100644
--- a/src/story/ui-chat.js
+++ b/src/story/ui-chat.js
@@ -1,7 +1,7 @@
 import { F } from "../engine/core.js";
+import { componentClass } from "../engine/prefab.js";
 import { UnityProgram, applyState } from "../engine/glsl.js";
 import { mat4 } from "../engine/math.js";
-import { GLTex } from "../engine/texture.js";
 import { UIAffine, UIDraw, UIError, UIImage, UINode, UISprite, UI_ATTRIBS, UI_STRIDE, uiCanvasSize } from "../engine/ugui.js";
 import { TMPText } from "../engine/uitext.js";
 import { StoryCommandError } from "./interfaces.js";
@@ -12,14 +12,14 @@ import { StoryText } from "./ui-ruby.js";
 // CanvasScaler ScaleWithScreenSize / Expand) with AdvChatView and its Target, and the AdvChatWindow prefab instances
 // (chat.json `windows`) attached under Target, laid out and drawn like the other story canvases: RectTransforms and
 // the auto layout (ui-layout.js), Image meshes (engine/ugui.js), TextMesh Pro text (engine/uitext.js) with the chat
-// windows' text bindings (ui/fonts.json `chatTexts`), CanvasGroup, CanvasRenderer alpha, the stencil Mask, the
+// windows' text bindings (story.fonts `texts`), CanvasGroup, CanvasRenderer alpha, the stencil Mask, the
 // ScrollRect content position and Soft Mask for uGUI's SoftMask / SoftMaskable. features/chat.js drives it as
 // AdvChatView does.
 //
 // Prefab records: {path, name, active, localPosition, localRotation, localScale, rect, components}, components with
 // `type` (engine) or `class` (MonoBehaviour), in hierarchy order.
 
-export const compOf = (rec, cls) => (rec.components || []).find((c) => (c.class || c.type) === cls) || null;
+export const compOf = (rec, cls) => (rec.components || []).find((c) => componentClass(c) === cls)?.fields || null;
 
 const LANGUAGE_ENGLISH = 1;                  // Fwk.Localization.LanguageMode.English
 // components of the chat window prefabs that draw nothing and change no layout here
@@ -35,12 +35,12 @@ const PASSIVE = new Set(["CanvasRenderer", "UIText", "LocalizeText", "GraphicCol
 // the untrimmed formula of UISprite when nothing is trimmed.
 export const chatSprite = (s) => {
   const tex = s.texture;
-  if (!tex || !tex.texture) throw new UIError(`sprite ${s.sprite}: no texture`);
-  if (s.downscaleMultiplier !== undefined && s.downscaleMultiplier !== 1) throw new UIError(`sprite ${s.sprite}: atlas variant scale`);
-  if (((s.settingsRaw | 0) >> 2) & 15) throw new UIError(`sprite ${s.sprite}: packing rotation not implemented`);
-  const sp = new UISprite(s.sprite, { rect: s.rect, border: s.border, pixelsPerUnit: s.pixelsToUnits, pivot: s.pivot,
+  if (!tex || !tex.id) throw new UIError(`sprite ${s.id}: no texture`);
+  if (s.downscaleMultiplier !== undefined && s.downscaleMultiplier !== 1) throw new UIError(`sprite ${s.id}: atlas variant scale`);
+  if (((s.settingsRaw | 0) >> 2) & 15) throw new UIError(`sprite ${s.id}: packing rotation not implemented`);
+  const sp = new UISprite(s.id, { rect: s.rect, border: s.border, pixelsPerUnit: s.pixelsToUnits, pivot: s.pivot,
                                       textureRect: s.textureRect, textureRectOffset: s.textureRectOffset },
-                          { width: tex.width, height: tex.height, name: tex.texture });
+                          tex);
   if (sp.trimmed && sp.hasBorder) {
     const tr = s.textureRect, off = s.textureRectOffset, b = s.border, W = tex.width, H = tex.height;
     const ox = tr.x - off.x, oy = tr.y - off.y;
@@ -59,20 +59,25 @@ export class ChatUINode extends UINode {
   constructor(rec, parent, host, src = rec.path) {
     super({ ...rec, canvasGroup: compOf(rec, "CanvasGroup") }, parent);
     this.src = src;
+    this.prefabId = host.prefabId;
+    this.sourcePath = src;
+    this.pathOf = host.pathOf;
+    this.componentId = (c) => `${this.prefabId.slice(0, this.prefabId.lastIndexOf(":"))}:${c.pathId}`;
     this.raw = rec;
     this.rendererAlpha = 1;                                // CanvasRenderer.GetAlpha (SetAlpha on the read label)
     const lg = compOf(rec, "HorizontalLayoutGroup") || compOf(rec, "VerticalLayoutGroup");
     const lgClass = lg ? (compOf(rec, "HorizontalLayoutGroup") ? "HorizontalLayoutGroup" : "VerticalLayoutGroup") : null;
     const le = compOf(rec, "LayoutElement"), csf = compOf(rec, "ContentSizeFitter");
     // the node record the auto layout reads (layout group / element present, enabled or not)
-    this.rec = { ...rec, layoutGroup: lg ? { ...lg, class: lgClass } : undefined, layoutElement: le || undefined };
+    this.rec = rec;
+    this.ignoreLayout = !!le?.m_IgnoreLayout;
     if (lg && lg.m_Enabled) this.layoutGroup = { ...lg, class: lgClass, m_Padding: { ...lg.m_Padding } };
     if (le && le.m_Enabled) this.layoutElement = { ...le };
     if (csf && csf.m_Enabled) this.contentSizeFitter = csf;
     if (host.visual === false) return;
     for (const c of rec.components || []) {
-      const cls = c.class || c.type;
-      if (!PASSIVE.has(cls) && c.m_Enabled !== 0) throw new UIError(`${rec.path}: ${cls} not implemented`);
+      const cls = componentClass(c);
+      if (!PASSIVE.has(cls) && c.fields.m_Enabled !== 0) throw new UIError(`${rec.path}: ${cls} not implemented`);
     }
     const im = compOf(rec, "Image");
     if (im) {
@@ -95,7 +100,7 @@ export class ChatUINode extends UINode {
     if (sr && sr.m_Enabled) this.scrollRect = sr;
     const tmp = compOf(rec, "TextMeshProUGUI");
     if (tmp) {
-      const b = host.binding(src);
+      const b = host.binding(src, this);
       if (b) {
         this.text = new TMPText(host.textHost, this, b);
         this.text.enabled = !!b.enabled;
@@ -363,7 +368,7 @@ export const softMaskParams = (maskNode, refPPU) => {
     if (img.m_PreserveAspect) throw new UIError(`${maskNode.path}: SoftMask with preserveAspect not implemented`);
     const sw = sp.rect.width, sh = sp.rect.height, w = full[2] - full[0], h = full[3] - full[1];
     const rect = [full[0] + pad[0] / sw * w, full[1] + pad[1] / sh * h, full[2] - pad[2] / sw * w, full[3] - pad[3] / sh * h];
-    return { rect, uvRect: outer, border: rect, uvBorder: outer, sliced: false, texture: sp.texture.name };
+    return { rect, uvRect: outer, border: rect, uvBorder: outer, sliced: false, texture: sp.texture.id };
   }
   if (!sp.inner) throw new UIError(`${maskNode.path}: SoftMask sprite without inner uv`);
   const scale = refPPU / (sp.pixelsPerUnit * img.m_PixelsPerUnitMultiplier);
@@ -375,27 +380,28 @@ export const softMaskParams = (maskNode, refPPU) => {
     if (size[axis] < sum && sum !== 0) { const k = size[axis] / sum; b[axis] *= k; b[axis + 2] *= k; }
   }
   const border = [full[0] + b[0], full[1] + b[1], full[2] - b[2], full[3] - b[3]];
-  return { rect, uvRect: outer, border, uvBorder: sp.inner, sliced: true, texture: sp.texture.name };
+  return { rect, uvRect: outer, border, uvBorder: sp.inner, sliced: true, texture: sp.texture.id };
 };
 
 // ------------------------------------------------------------------------------------------------ the canvas
-// UIAdvChatWidget's ChatCanvas with AdvChatView and Target (ui/ui.json `chatWidget`), the chat windows under Target.
+// UIAdvChatWidget's ChatCanvas with AdvChatView and Target (story.ui `chatWidget`), the chat windows under Target.
 // host: {textHost (fontAsset / material: the story UI), binding(window, src), languageMode}.
 export class ChatCanvasUI {
-  constructor(widget) {
+  constructor(prefab) {
+    const widget = { nodes: [...prefab.nodes.values()].map((e) => e.node) };
     const byPath = new Map(widget.nodes.map((n) => [n.path, n]));
-    const canvasRec = widget.nodes.find((n) => n.canvas);
+    const canvasRec = widget.nodes.find((n) => compOf(n, "Canvas"));
     if (!canvasRec) throw new UIError("chatWidget: no canvas node");
-    const c = canvasRec.canvas, s = canvasRec.canvasScaler;
+    const c = compOf(canvasRec, "Canvas"), s = compOf(canvasRec, "CanvasScaler");
     if (!c.m_Enabled || c.m_RenderMode !== 1 || c.m_PixelPerfect || c.m_OverrideSorting)
       throw new UIError("ChatCanvas: canvas settings outside the prefab values (Screen Space - Camera)");
     if (!s || !s.m_Enabled || s.m_UiScaleMode !== 1 || s.m_ScreenMatchMode !== 1)
       throw new UIError("ChatCanvas: CanvasScaler is not ScaleWithScreenSize / Expand");
     this.sortingOrder = c.m_SortingOrder; this.planeDistance = c.m_PlaneDistance; this.scaler = s;
-    const viewRec = widget.nodes.find((n) => n.chatView);
+    const viewRec = widget.nodes.find((n) => compOf(n, "AdvChatView"));
     if (!viewRec) throw new UIError("chatWidget: no AdvChatView");
-    this.chatView = viewRec.chatView;
-    const targetPath = this.chatView._windowParentRect;
+    this.chatView = compOf(viewRec, "AdvChatView");
+    const targetPath = prefab.pathOf(this.chatView._windowParentRect);
     const targetRec = byPath.get(targetPath);
     if (!targetRec) throw new UIError(`chatWidget: ${targetPath} (_windowParentRect) not in the data`);
     const host = { sprite: () => { throw new UIError("chatWidget: sprites not implemented"); }, binding: () => null };
@@ -404,7 +410,7 @@ export class ChatCanvasUI {
     this.view = new ChatUINode(plain(viewRec), this.root, host);
     if (targetRec.path.slice(0, targetRec.path.lastIndexOf("/")) !== viewRec.path) throw new UIError("chatWidget: Target is not a child of AdvChatView");
     this.target = new ChatUINode(plain(targetRec), this.view, host);
-    const cg = targetRec.canvasGroup;
+    const cg = compOf(targetRec, "CanvasGroup");
     this.target.canvasGroup = cg && cg.m_Enabled ? { alpha: cg.m_Alpha, ignoreParentGroups: !!cg.m_IgnoreParentGroups } : null;
     if (this.target.sizeDelta.x !== 0 || this.target.sizeDelta.y !== 0 || this.target.anchorMin.x !== this.target.anchorMax.x ||
         this.target.anchorMin.y !== this.target.anchorMax.y) throw new UIError("chatWidget: Target is not a point rect");
@@ -438,7 +444,7 @@ export class ChatCanvasUI {
       if (n.image && n.image.m_Enabled) {
         const mesh = UIImage.build(n, n.image, n.image.spriteObj, refPPU);
         const it = { node: n, kind: "image", verts: UIDraw.pack(mesh.verts, n, a), idx: Uint32Array.from(mesh.idx),
-                     texture: n.image.spriteObj ? n.image.spriteObj.texture.name : null };
+                     texture: n.image.spriteObj ? n.image.spriteObj.texture.id : null };
         if (masking) {
           const st = maskStencil(depth, n.mask.showGraphic);
           it.stencil = st.push;
@@ -477,13 +483,13 @@ const scaleOf = (n) => Math.hypot(n.matrix[2], n.matrix[3]);
 // of the perspective camera, scaled to fill the view (UnityObjectToClipPos of the canvas vertices; TMP's SDF scale
 // includes the text's world scale and its perspective filter).
 export class ChatCanvasGL {
-  constructor(gl, ui, assets) {
-    this.gl = gl; this.ui = ui; this.assets = assets;
+  constructor(gl, ui, objects) {
+    this.gl = gl; this.ui = ui; this.objects = objects;
     this.tex = new Map(); this.buf = null; this.fbo = null; this.soft = null; this.mats = new Map();
   }
 
   async load(textures) {
-    for (const [p, desc] of textures) if (!this.tex.has(p)) this.tex.set(p, await GLTex.load(this.gl, "", desc, this.assets));
+    for (const id of textures.keys()) if (!this.tex.has(id)) this.tex.set(id, await this.objects.texture(id));
     const gl = this.gl;
     this.buf = { vao: gl.createVertexArray(), vbo: gl.createBuffer(), ibo: gl.createBuffer() };
   }
@@ -617,4 +623,3 @@ export class ChatCanvasGL {
     this.soft = null;
   }
 }
-
diff --git a/src/story/ui-fonts.js b/src/story/ui-fonts.js
index 377d6fc..dfd6616 100644
--- a/src/story/ui-fonts.js
+++ b/src/story/ui-fonts.js
@@ -3,7 +3,7 @@ import { BrowserGlyphFont, canvasRasterizer } from "./browser-font.js";
 
 // The font asset records a story UI lays its texts out with (the text host's fontAsset, engine/uitext.js).
 //
-// Font data made from open fonts (ui/fonts.json `source` "open") has glyphs with the metrics of the open font, and
+// Font data made from open fonts (story.fonts `source` "open") has glyphs with the metrics of the open font, and
 // with them its face's line height, ascent and descent. The game lays text out with the line metrics of its own font
 // assets, and the language's line spacing (LocalizeManager.ApplyLanguageLineSpacing) is set for them: English's -100
 // (one em less) takes the line gap of the game's primary font (A-OTF-ShinGoPr6N: line height 2 em, ascent 0.88,
@@ -13,9 +13,9 @@ import { BrowserGlyphFont, canvasRasterizer } from "./browser-font.js";
 // language. The glyphs keep their own metrics (the open CJK faces share the game's ideographic em box, 0.88 / -0.12).
 //
 // The game font of an open font asset, in this order:
-// - its font role: the fontRole of the text nodes whose bindings (localized.fontAsset) use it (the story UI's nodes,
-//   its dialogs' and chat windows'), or the role ui/languages.json `roles` names it for; the role's line metrics are
-//   ui.json `textStyle.roles` (read from the game's font assets of the language);
+// - its font role: the fontRole of the text nodes whose bindings (font.fontAsset) use it (the story UI's nodes,
+//   its dialogs' and chat windows'), or the role story.ui.language `roles` names it for; the role's line metrics are
+//   story.ui `textStyle.roles` (read from the game's font assets of the language);
 // - else the game font asset its name stands in for ("<open font> (<game font asset>)", a fallback of another asset
 //   such as the Japanese font behind Korean text) when GAME_FONT_LINES has it.
 // Data from the game's fonts is taken as it is.
@@ -31,8 +31,8 @@ export const GAME_FONT_LINES = Object.freeze({
 });
 
 export class StoryFontAssets {
-  // fonts = ui/fonts.json (or ui/simple/fonts.json); doc = the ui.json record document laid out with them;
-  // language = ui/languages.json (may be null)
+  // fonts = story.fonts; doc = the UI product laid out with them;
+  // language = the UI product's language settings (may be null)
   // options.rasterizer(spec) -> the glyph rasterizer of a browser font (browser-font.js; Canvas 2D by default)
   constructor(fonts, doc, language, options = {}) {
     this.fonts = fonts;
@@ -49,6 +49,8 @@ export class StoryFontAssets {
     const roles = (doc && doc.textStyle && doc.textStyle.roles) || {};
     const add = (asset, m) => { if (typeof asset === "string" && m && !this.lines.has(asset)) this.lines.set(asset, m); };
     for (const [role, r] of Object.entries((language && language.roles) || {})) add(r && r.fontAsset, roles[role]);
+    for (const t of Object.values(fonts.texts || {}))
+      if (t.style) add(t.font?.fontAsset, roles[t.style.fontRole]);
     const byNodes = (nodes, bindings) => {
       for (const n of nodes || []) {
         const t = n.textStyle && bindings ? bindings[n.path] : null;
diff --git a/src/story/ui-layout.js b/src/story/ui-layout.js
index 47b8649..b640a92 100644
--- a/src/story/ui-layout.js
+++ b/src/story/ui-layout.js
@@ -52,7 +52,7 @@ export class StoryLayout {
   // PerformLayoutCalculation: a node without layout elements and without a layout group ends the walk; the layout
   // elements' inputs are computed on demand, the layout group's CalcAlongAxis here
   _calc(n, axis) {
-    if (!(this._hasElements(n) || n.rec.layoutGroup)) return;
+    if (!(this._hasElements(n) || n.layoutGroup)) return;
     for (const c of n.children) this._calc(c, axis);
     if (n.layoutGroup && n.activeInHierarchy) this._calcAlongAxis(n, axis);
   }
@@ -154,7 +154,7 @@ export class StoryLayout {
   // LayoutGroup.rectChildren: children active in the hierarchy, without an ILayoutIgnorer that ignores layout
   // (LayoutElement.ignoreLayout, read whether or not the component is enabled)
   _rectChildren(n) {
-    return n.children.filter((c) => c.activeInHierarchy && !(c.rec.layoutElement && c.rec.layoutElement.m_IgnoreLayout));
+    return n.children.filter((c) => c.activeInHierarchy && !c.ignoreLayout);
   }
 
   // GetChildSizes: not controlled -> min = preferred = sizeDelta, flexible 0; force expand -> flexible >= 1
@@ -236,4 +236,3 @@ export class StoryLayout {
     n.layoutIn(n.parent.rect, n.parent.matrix);
   }
 }
-
diff --git a/src/story/ui-objects.js b/src/story/ui-objects.js
new file mode 100644
index 0000000..2cc61d9
--- /dev/null
+++ b/src/story/ui-objects.js
@@ -0,0 +1,38 @@
+import { componentClass } from "../engine/prefab.js";
+import { UINode, UIError } from "../engine/ugui.js";
+
+const TEXT_CLASSES = new Set(["TextMeshProUGUI", "RubyTextMeshProUGUI", "RubyEmojiTextMeshProUGUI"]);
+
+// Instantiate a prefab subtree as UI nodes. Source component ids and source paths remain available after parenting.
+export const uiTree = (objects, id, { root = null, parent = null, nodes = new Map(), Node = UINode, include = null } = {}) => {
+  const prefab = objects.prefab(id), source = root || prefab.root.name;
+  const destination = parent ? `${parent.path}/${source.split("/").at(-1)}` : source;
+  const pathOf = (path) => path === source ? destination : path.startsWith(`${source}/`)
+    ? destination + path.slice(source.length) : path;
+  for (const [path, entry] of prefab.nodes) {
+    if (path !== source && !path.startsWith(`${source}/`)) continue;
+    if (include && !include(path, entry.node)) continue;
+    const mapped = pathOf(path), p = path === source ? parent : nodes.get(mapped.slice(0, mapped.lastIndexOf("/")));
+    if (nodes.has(mapped)) throw new UIError(`${mapped}: duplicate UI node`);
+    const n = new Node({ ...entry.node, path: mapped }, p);
+    n.prefabId = id;
+    n.sourcePath = path;
+    n.ref = (ref) => ref ? nodes.get(pathOf(prefab.pathOf(ref))) || null : null;
+    n.componentId = (c) => `${id.slice(0, id.lastIndexOf(":"))}:${c.pathId}`;
+    nodes.set(mapped, n);
+  }
+  return nodes.get(destination);
+};
+
+// Text components keep their serialized TMP fields; the language product supplies the font/material binding.
+export const uiTextBinding = (node, fonts) => {
+  const c = node.rec.components.find((x) => TEXT_CLASSES.has(componentClass(x)));
+  if (!c) return null;
+  const id = node.componentId(c), binding = fonts.texts[id];
+  if (!binding) throw new UIError(`${node.path}: no font binding for ${id}`);
+  const t = c.fields, cls = componentClass(c);
+  const sprite = fonts.sprites?.[id]?.spriteAsset || null;
+  return { ...t, id, class: cls, enabled: !!t.m_Enabled, localized: binding.font,
+    spriteAsset: sprite, localizeKoreanAdjust: binding.localizeKoreanAdjust,
+    ruby: cls.includes("Ruby") ? t : null, uiRubyText: node.fields("UIRubyText") };
+};
diff --git a/src/story/ui-talk.js b/src/story/ui-talk.js
index 915891d..be33a89 100644
--- a/src/story/ui-talk.js
+++ b/src/story/ui-talk.js
@@ -72,12 +72,12 @@ export const countRenderedCharacters = (text) => {
 };
 
 export class StoryTalkWindow {
-  constructor(ui) {
+  constructor(ui, record = ui.part.window.fields("UIAdvTalkWindow")) {
     this.ui = ui;
     const p = ui.part;
     this.p = p;
     if (p.background && !p.background.canvasGroup) throw new UIError("TalkBackground has no CanvasGroup");
-    const tw = p.window.rec.talkWindow;
+    const tw = record;
     if (!tw) throw new UIError(`${p.window.path}: no UIAdvTalkWindow record`);
     this.rec = tw;
     this.useBackdropFilter = !!tw._useBackdropFilter;   // UIAdvTalkWindow.UseBackdropFilter
@@ -118,7 +118,7 @@ export class StoryTalkWindow {
   // CanvasGroup.DOFade(to, d): DOTween.To on alpha with the default ease (DOTweenSettings defaultEaseType), start
   // value read on the first update
   _fade(cg, to, duration) {
-    return new UITween(this.ui.tweens, { duration, getFrom: () => cg.alpha, to, ease: this.ui.doc.dotween.defaultEaseType,
+    return new UITween(this.ui.tweens, { duration, getFrom: () => cg.alpha, to, ease: this.ui.dotween.defaultEaseType,
                                          apply: (v) => { cg.alpha = v; } });
   }
 
diff --git a/src/story/ui-transition.js b/src/story/ui-transition.js
index 8f745e0..1b71e2a 100644
--- a/src/story/ui-transition.js
+++ b/src/story/ui-transition.js
@@ -9,11 +9,11 @@ import { UIError } from "../engine/ugui.js";
 export class StoryRuleTransition {
   constructor(ui) {
     this.ui = ui;
-    const node = ui.part.rule, rt = node.rec.ruleTransition, doc = ui.doc;
-    if (!rt || !doc.materials[rt.material]) throw new UIError("RuleTransition: UI-Transition material not in the data");
+    const node = ui.part.rule, rt = node.fields("UIAdvRuleTransitionView");
+    if (!rt?._material) throw new UIError("RuleTransition: UI-Transition material not in the data");
     // UIRuleTransitionView: the Image draws with `_material` (UI-Transition); its properties are set per fade
-    node.image.material = rt.material;
-    const tm = doc.materials[rt.material];
+    node.image.material = ui.uiMaterial(rt._material);
+    const tm = ui.objects.material(rt._material);
     this.node = node;
     this.texture = null;
     this.color = tm.colors._Color; this.val = tm.floats._Val; this.useGradient = tm.floats._UseGradient;
@@ -36,12 +36,12 @@ export class StoryRuleTransition {
 
   // GetTransitionSettings(address) -> Fwk.Transition.RuleTransitionSettings (_texture, _gradient, _easingCurve)
   settings(address) {
-    const s = this.ui.doc.transitions[address];
-    if (!s) throw new UIError(`transition ${address} not in the data`);
+    const a = this.ui.data.asset(`Adv/Transition/${address}`);
+    if (a.objects.length !== 1) throw new UIError(`transition ${address}: expected one settings object`);
+    const s = this.ui.objects.mono(a.objects[0]);
     const keys = s._easingCurve.m_Curve;
     if (!keys.length || keys.some((k) => k.weightedMode !== 0)) throw new UIError(`${address}: weighted easing curve not implemented`);
-    const texture = s._texture ? s._texture.texture : null;
-    if (texture && !this.ui.doc.textures[texture]) throw new UIError(`${address}: rule texture not in the data`);
+    const texture = this.ui.objects.id(s._texture, "Texture2D");
     return { address, texture, gradient: s._gradient, curve: keys };
   }
 
@@ -73,8 +73,8 @@ export class StoryLetterBox {
     this.ui = ui;
     const doc = ui.doc, p = ui.part;
     // UIAdvWidget.SetLetterBoxSprite (AdvPlayer.Init): Textures/letterbox-image on both band Images
-    const lb = ui.sprites.get(doc.letterBoxSprite);
-    if (!lb) throw new UIError(`letterbox sprite ${doc.letterBoxSprite} not in the data`);
+    const lb = ui.sprite(doc.letterbox);
+    if (!lb) throw new UIError(`letterbox sprite ${doc.letterbox} not in the data`);
     p.topBand.image.spriteObj = lb; p.bottomBand.image.spriteObj = lb;
     this.root = ui.letterBox;
     this._key = null;
diff --git a/src/story/ui.js b/src/story/ui.js
index 9bec29a..a22ec69 100644
--- a/src/story/ui.js
+++ b/src/story/ui.js
@@ -1,10 +1,10 @@
-import { F, join } from "../engine/core.js";
-import { ShaderLib } from "../engine/glsl.js";
+import { F } from "../engine/core.js";
 import { GLTex } from "../engine/texture.js";
 import { Tweens } from "../engine/tween.js";
-import { UIAnimator, UIClip, UIDraw, UIError, UIImage, UINode, UISprite, UITween, uiCanvasSize } from "../engine/ugui.js";
+import { UIAnimator, UIDraw, UIError, UIImage, UISprite, UITween, uiCanvasSize } from "../engine/ugui.js";
 import { TMPText, UIGradientMod, tmpSpriteAsset, tmpUnsupported } from "../engine/uitext.js";
 import { ADV_CANVAS_LAYER, StoryCommandError, createStoryUILayers } from "./interfaces.js";
+import { uiTree, uiTextBinding } from "./ui-objects.js";
 import { StoryFontAssets } from "./ui-fonts.js";
 import { StoryLayout } from "./ui-layout.js";
 import { StoryText, countedText, shownText } from "./ui-ruby.js";
@@ -23,10 +23,8 @@ import { DualKawaseBlur, UIBlur, blurPass } from "./simple/home/blur.js";
 // ui-ruby.js, the rule transition and the letterbox ui-transition.js. The UI's timing runs on the player loop with or
 // without a GL context (gl = null: layout, geometry and timing only).
 //
-// Data: ui/ui.json (nodes, sprites, textures, UI materials, clips, controllers, transitions, player settings, the blur
-// pass settings with a backdrop-filter talk window), the language's ui/fonts.json (font assets, glyph pages, text
-// materials, the emoji sprite asset, per text node the TMP text record and its localized font binding) and
-// ui/languages.json (LanguageMode of the language).
+// Data: story.ui references prefabs and settings by object id. story.fonts supplies per-component font and material
+// bindings, glyph pages and sprite assets. story.ui.language holds the language mode and localization settings.
 
 export const ADVUI_WIDGET = "UIAdvWidget";
 export const ADVUI_FRONT = "UIAdvWidget/FrontCanvas";
@@ -61,95 +59,80 @@ const MENU_PARTS = {
 };
 
 export class StoryUI {
-  // gl may be null (layout, geometry and timing only). doc = ui/ui.json; fonts = ui/fonts.json and language =
-  // ui/languages.json of the language `lang`; assets = the story's AssetStore (textures, shaders, glyph pages; the
-  // store bound to gl when omitted); dir = the ui directory in the store.
-  constructor(gl, loop, doc, { assets, dir = "ui", lang, fonts, language }) {
-    if (!fonts || !fonts.texts) throw new UIError("StoryUI: ui/fonts.json missing");
-    if (!language || typeof language.mode !== "number") throw new UIError("StoryUI: ui/languages.json missing");
+  // gl may be null for layout, geometry and timing. doc is story.ui; data supplies the selected language's font
+  // product, and objects resolves the shared prefab, material, texture and animation objects.
+  constructor(gl, loop, doc, { assets, data, objects }) {
+    const fonts = data.fonts, language = doc.language, lang = data.language;
+    if (!fonts?.texts) throw new UIError("StoryUI: font product missing");
+    if (typeof language?.mode !== "number") throw new UIError("StoryUI: language missing");
     this.gl = gl; this.loop = loop; this.doc = doc; this.fonts = fonts; this.language = language; this.lang = lang;
-    this.assets = assets; this.dir = dir;
-    this._materialInstances = new Map();            // TMP_Text.fontMaterial instances: name -> text material record
+    this.assets = assets; this.data = data; this.objects = objects; this.dir = data.fontDir;
+    this.dotween = objects.mono(doc.settings.dotween);
+    this._materialInstances = new Map();
     this._spriteAssets = new Map();
-    // LocalizeManager.EmojiSpriteAsset (UIText gives it to its text; TmpTextHelper.CombineEmojiSequences' fallback)
     this.emojiSpriteAsset = fonts.emojiSpriteAsset ? tmpSpriteAsset(this.spriteAsset(fonts.emojiSpriteAsset)) : null;
-    // hierarchy order (parents first, siblings in order); the widget's other canvases are skipped with their subtrees
-    const byPath = new Map(), skipped = new Set();
-    for (const rec of doc.nodes) {
-      const parentPath = rec.path.slice(0, rec.path.lastIndexOf("/"));
-      if (skipped.has(parentPath)) { skipped.add(rec.path); continue; }
-      const parent = byPath.get(parentPath) || null;
-      if (!parent && parentPath === ADVUI_WIDGET && rec.path !== ADVUI_FRONT && rec.path !== ADVUI_LETTERBOX) {
-        skipped.add(rec.path); continue;
-      }
-      if (!parent && rec.path !== ADVUI_FRONT && rec.path !== ADVUI_LETTERBOX)
-        throw new UIError(`ui node ${rec.path} has no parent in the data`);
-      byPath.set(rec.path, new UINode(rec, parent));
+    const byPath = this.nodes = new Map();
+    this.front = uiTree(objects, doc.widget, { root: ADVUI_FRONT, nodes: byPath });
+    this.letterBox = uiTree(objects, doc.widget, { root: ADVUI_LETTERBOX, nodes: byPath });
+    const neededWindows = new Set([ADVUI_DEFAULT_WINDOW, ...data.episode.commands
+      .filter((c) => c.cmd === "TalkWindow" && !c.IgnoreData).map((c) => c.TargetAssetName)]);
+    const talkView = this.front.find(ADVUI_TALK_VIEW);
+    for (const name of neededWindows) {
+      const id = doc.talkWindows[name];
+      if (!id) throw new UIError(`talk window ${name}: not in the UI product`);
+      uiTree(objects, id, { parent: talkView, nodes: byPath });
     }
-    this.nodes = byPath;
-    this.front = byPath.get(ADVUI_FRONT);
-    this.letterBox = byPath.get(ADVUI_LETTERBOX);
-    if (!this.front || !this.letterBox) throw new UIError("ui.json lacks FrontCanvas or AdvLetterBoxCanvas");
-    const scaler = this.front.rec.canvasScaler;
+    const scaler = this.front.fields("CanvasScaler");
     if (!scaler || !scaler.m_Enabled || scaler.m_UiScaleMode !== 1 || scaler.m_ScreenMatchMode !== 1)
       throw new UIError("FrontCanvas: CanvasScaler is not ScaleWithScreenSize / Expand");
-    if (this.front.rec.canvas.m_RenderMode !== 1 || this.letterBox.rec.canvas.m_RenderMode !== 0 ||
-        this.front.rec.canvas.m_PixelPerfect || this.letterBox.rec.canvas.m_PixelPerfect)
+    const frontCanvas = this.front.fields("Canvas"), letterCanvas = this.letterBox.fields("Canvas");
+    if (frontCanvas.m_RenderMode !== 1 || letterCanvas.m_RenderMode !== 0 || frontCanvas.m_PixelPerfect || letterCanvas.m_PixelPerfect)
       throw new UIError("canvas render modes differ from the prefab (Camera / Overlay, not pixel perfect)");
     this.scaler = scaler;
-    // uGUI auto layout (ui-layout.js); the text component of a node is its ILayoutElement when enabled
-    this.autoLayout = new StoryLayout(scaler.m_ReferencePixelsPerUnit, (n) => (n.text && n.text.enabled ? n.text : null));
-    this.sprites = new Map(Object.entries(doc.sprites).map(([n, s]) => {
-      const t = doc.textures[s.texture];
-      if (!t) throw new UIError(`sprite ${n}: texture ${s.texture} not in the data`);
-      return [n, new UISprite(n, s, t)];
-    }));
-    this._fonts = new StoryFontAssets(fonts, doc, language);   // open fonts: the game's line metrics
-    this._clipCache = Object.fromEntries(Object.entries(doc.clips).map(([k, c]) => [k, new UIClip(c)]));
+    this.autoLayout = new StoryLayout(scaler.m_ReferencePixelsPerUnit, (n) => n.text?.enabled ? n.text : null);
+    this.sprites = new Map();
+    this.uiMaterials = new Map([[ADVUI_DEFAULT_MATERIAL,
+      { shader: "UI/Default", keywords: [], floats: {}, colors: {} }]]);
+    this._fonts = new StoryFontAssets(fonts, doc, language);
     this.animators = [];
     for (const n of byPath.values()) {
-      const r = n.rec;
-      if (r.image) {
-        const sp = r.image.sprite;
-        if (sp && !this.sprites.has(sp)) throw new UIError(`${n.path}: sprite ${sp} not in the data`);
-        n.image = { ...r.image, spriteObj: sp ? this.sprites.get(sp) : null, material: r.image.material || ADVUI_DEFAULT_MATERIAL };
-        if (!doc.materials[n.image.material]) throw new UIError(`${n.path}: material ${n.image.material} not in the data`);
+      const g = n.fields("Image");
+      if (g) {
+        n.image = { ...g, spriteObj: this.sprite(g.m_Sprite), material: this.uiMaterial(g.m_Material) };
       }
-      if (r.gradient && r.gradient.enabled) n.gradient = r.gradient;
-      if (r.textStyle) {
-        let t = fonts.texts[n.path];
-        if (!t) throw new UIError(`${n.path}: no text binding in ui/fonts.json`);
-        // BiliBili.Locale.LocalizeKoreanAdjust.Apply (from OnEnable and the font-changed callback OnEnable registers,
-        // so only for an enabled component): in the Korean language mode _koreanFontStyle ForceNormal (1) clears and
-        // ForceBold (2) sets the Bold style of the serialized font style; other modes keep it
+      const gradient = n.fields("UIGradientImage");
+      if (gradient?.m_Enabled) n.gradient = { gradient: gradient._gradient, angleDeg: gradient._angleDeg,
+        splitAtKeysWhenAxisAligned: gradient._splitAtKeysWhenAxisAligned, blendMode: gradient._blendMode };
+      let t = uiTextBinding(n, fonts);
+      if (t) {
         const ko = t.localizeKoreanAdjust;
-        if (ko && ko.m_Enabled && language.mode === LANGUAGE_KOREAN && (ko._koreanFontStyle === 1 || ko._koreanFontStyle === 2))
+        if (ko?.m_Enabled && language.mode === LANGUAGE_KOREAN && (ko._koreanFontStyle === 1 || ko._koreanFontStyle === 2))
           t = { ...t, m_fontStyle: ko._koreanFontStyle === 2 ? t.m_fontStyle | 1 : t.m_fontStyle & ~1 };
         n.text = new TMPText(this, n, t);
-        n.text.enabled = !!t.enabled;
-        n.textClass = t.class;
-        // LocalizeText.OnFontChanged, English only: enableWordWrapping = true (and overflow mode 0) unless the object's
-        // name contains "nowrap" (IndexOf, ordinal ignore case)
+        n.text.enabled = t.enabled; n.textClass = t.class;
         if (language.mode === LANGUAGE_ENGLISH && !n.name.toLowerCase().includes("nowrap")) n.text.setWrapping(1);
         n.storyText = new StoryText(n.text, t, this.emojiSpriteAsset);
       }
-      if (r.animator) {
-        const a = r.animator;
-        const ctrl = doc.controllers[a.controller];
-        if (!ctrl) throw new UIError(`${n.path}: controller ${a.controller} not in the data`);
-        if (a.updateMode !== 0 || !a.enabled || a.keepStateOnDisable)
+      const a = n.fields("Animator");
+      if (a?.m_Controller) {
+        if (a.m_UpdateMode !== 0 || !a.m_Enabled || a.m_KeepAnimatorStateOnDisable)
           throw new UIError(`${n.path}: animator settings outside the prefab values`);
-        n.animator = new UIAnimator(n, ctrl, this._clipCache);
+        n.animator = UIAnimator.fromObjects(n, objects, a.m_Controller, n.prefabId, n.sourcePath);
         this.animators.push(n.animator);
       }
-      if (r.layoutGroup && r.layoutGroup.m_Enabled) n.layoutGroup = r.layoutGroup;
-      if (r.contentSizeFitter && r.contentSizeFitter.m_Enabled) n.contentSizeFitter = r.contentSizeFitter;
-      if (r.layoutElement && r.layoutElement.m_Enabled) n.layoutElement = r.layoutElement;
-      if (r.outline && r.outline.enabled) throw new UIError(`${n.path}: enabled Outline effect not implemented`);
-      if (r.safeAreaEdgeAnchor && r.safeAreaEdgeAnchor.enabled) n.safeAreaEdgeAnchor = r.safeAreaEdgeAnchor;
+      for (const cls of ["HorizontalLayoutGroup", "VerticalLayoutGroup"]) {
+        const layout = n.fields(cls);
+        if (layout?.m_Enabled) n.layoutGroup = { ...layout, class: cls };
+      }
+      const fitter = n.fields("ContentSizeFitter"), element = n.fields("LayoutElement");
+      if (fitter?.m_Enabled) n.contentSizeFitter = fitter;
+      if (element?.m_Enabled) n.layoutElement = element;
+      if (n.fields("Outline")?.m_Enabled) throw new UIError(`${n.path}: enabled Outline effect not implemented`);
+      const edge = n.fields("UISafeAreaEdgeAnchor");
+      if (edge?.m_Enabled) n.safeAreaEdgeAnchor = edge;
     }
     const F_ = (p) => this.front.find(p);
-    const opt = (p) => byPath.get(`${ADVUI_FRONT}/${p}`) || null, ref = (p) => (p ? byPath.get(p) || null : null);
+    const opt = (p) => byPath.get(`${ADVUI_FRONT}/${p}`) || null, ref = (r) => (r ? this.front.ref(r) : null);
     const flashView = opt("FlashView"), subtitlesView = opt("UISafeArea/UIContainer/SubtitlesView");
     this.part = {
       rule: F_("RuleTransition"), location: F_("LocationVIew"), locationText: F_("LocationVIew/LocationText"),
@@ -160,9 +143,9 @@ export class StoryUI {
       topBand: this.letterBox.find("TopBand"), bottomBand: this.letterBox.find("BottomBand"),
       uiContainer: F_("UISafeArea/UIContainer"),
       // AdvFlashView._flash; AdvSubtitlesView._subtitles / _subtitlesText; AdvFrontScreenView._nextIndicator
-      flash: flashView && flashView.rec.flashView ? ref(flashView.rec.flashView._flash) : null,
-      subtitles: subtitlesView && subtitlesView.rec.subtitlesView ? ref(subtitlesView.rec.subtitlesView._subtitles) : null,
-      subtitlesText: subtitlesView && subtitlesView.rec.subtitlesView ? ref(subtitlesView.rec.subtitlesView._subtitlesText) : null,
+      flash: flashView?.fields("AdvFlashView") ? ref(flashView.fields("AdvFlashView")._flash) : null,
+      subtitles: subtitlesView?.fields("AdvSubtitlesView") ? ref(subtitlesView.fields("AdvSubtitlesView")._subtitles) : null,
+      subtitlesText: subtitlesView?.fields("AdvSubtitlesView") ? ref(subtitlesView.fields("AdvSubtitlesView")._subtitlesText) : null,
       frontNextIndicator: opt("UISafeArea/UIContainer/NextIndicator"),
       menu: opt(MENU),
       // UIAdvWidget._centerTalkBackdropCanvasGroup / _centerTalkBackdropImage (in the data with a backdrop-filter window)
@@ -177,16 +160,16 @@ export class StoryUI {
       return n.canvasGroup;
     };
     // AdvTalkLogView._canvasGroup (the backlog, in the data with its view record)
-    const talkLogView = opt("TalkLogView"), tl = talkLogView && talkLogView.rec.talkLogView;
+    const talkLogView = opt("TalkLogView"), tl = talkLogView?.fields("AdvTalkLogView");
     p.talkLog = tl ? { group: groupRef(tl._canvasGroup, "AdvTalkLogView._canvasGroup") } : null;
     // AdvChoiceView._canvasGroup and _choiceItems: each item's GameObject and AdvChoiceItem._canvasGroup
-    const choiceView = opt("UISafeArea/UIContainer/ChoiceView"), cv = choiceView && choiceView.rec.choiceView;
+    const choiceView = opt("UISafeArea/UIContainer/ChoiceView"), cv = choiceView?.fields("AdvChoiceView");
     p.choices = cv ? {
       group: groupRef(cv._canvasGroup, "AdvChoiceView._canvasGroup"),
       items: cv._choiceItems.map((path) => {
-        const n = ref(path), rec = n && n.rec.behaviours && n.rec.behaviours.AdvChoiceItem;
-        if (!rec || rec.length !== 1) throw new UIError(`AdvChoiceView._choiceItems: ${path} has no AdvChoiceItem in the data`);
-        return { node: n, group: groupRef(rec[0]._canvasGroup, "AdvChoiceItem._canvasGroup") };
+        const n = ref(path), rec = n?.fields("AdvChoiceItem");
+        if (!rec) throw new UIError(`AdvChoiceView._choiceItems: ${path} has no AdvChoiceItem in the data`);
+        return { node: n, group: groupRef(rec._canvasGroup, "AdvChoiceItem._canvasGroup") };
       }),
     } : null;
     if (p.flash && !p.flash.image) throw new UIError("FlashView: no Image");
@@ -209,7 +192,7 @@ export class StoryUI {
       const find = (rel) => (rel ? node.find(rel) : null);
       const part = { window: node };
       for (const [k, rel] of Object.entries(refs)) part[k] = find(rel);
-      const host = { part, loop, tweens: this.tweens, language, doc, setActive: (n, v) => this.setActive(n, v),
+      const host = { part, loop, tweens: this.tweens, language, dotween: this.dotween, setActive: (n, v) => this.setActive(n, v),
                      setTextColor: (n, c) => this._setTextColor(n, c), setTextOutlineColor: (n, c) => this._setOutlineColor(n, c) };
       this.windows.set(node.name, { name: node.name, node, part, talk: new StoryTalkWindow(host) });
     }
@@ -221,12 +204,12 @@ export class StoryUI {
     this._window = null;
     this._view = { playbackSpeed: 1, autoIcon: false, fastIcon: false };
     this._backdropFade = null;
-    // the UI blur (UIManager's UIBlurController and the renderer feature's pass settings, ui.json `blur`) and
+    // the UI blur (UIManager's UIBlurController and the renderer feature's pass settings, UIRendererFeature settings) and
     // UIAdvWidget's blur scope (_advBlurScope, _isAdvBlurScopeForBackdrop, _isTalkLogVisible: the backlog is not
     // opened here)
-    this.blurParams = doc.blur || null;
+    this.blurParams = objects.uiBlur(doc.graphics.graphics, 0);
     if ([...this.windows.values()].some((w) => w.talk.useBackdropFilter) && !this.blurParams)
-      throw new UIError("ui.json lacks `blur`, which a backdrop-filter talk window needs");
+      throw new UIError("story graphics lack a UI blur feature, which a backdrop-filter talk window needs");
     this.blur = new UIBlur(loop);
     this._advBlurScope = null;
     this._isAdvBlurScopeForBackdrop = false;
@@ -252,6 +235,23 @@ export class StoryUI {
   }
 
   // ------------------------------------------------------------ text host (engine/uitext.js)
+  sprite(ref) {
+    const id = this.objects.id(ref, "Sprite");
+    if (id === null) return null;
+    if (!this.sprites.has(id)) {
+      const s = this.objects.sprite(id);
+      this.sprites.set(id, new UISprite(id, { ...s, pixelsPerUnit: s.pixelsToUnits }, s.texture));
+    }
+    return this.sprites.get(id);
+  }
+
+  uiMaterial(ref) {
+    const id = this.objects.id(ref, "Material");
+    if (id === null) return ADVUI_DEFAULT_MATERIAL;
+    if (!this.uiMaterials.has(id)) this.uiMaterials.set(id, this.objects.material(id));
+    return id;
+  }
+
   fontAsset(name) {
     const f = this._fonts.get(name);
     if (!f) throw new UIError(`font asset ${name} not in ui/fonts.json`);
@@ -358,19 +358,26 @@ export class StoryUI {
     const gl = this.gl;
     if (!gl) return;
     const assets = this.assets || undefined;
-    this.lib = new ShaderLib(gl, join(this.dir, this.doc.shaders.index.replace(/\/shaders\.json$/, "")), assets);
+    this.lib = this.objects.lib;
     this.solid = {
       white: GLTex.solid(gl, [255, 255, 255, 255], "white"), black: GLTex.solid(gl, [0, 0, 0, 255], "black"),
       gray: GLTex.solid(gl, [128, 128, 128, 255], "gray"), bump: GLTex.solid(gl, [128, 128, 255, 255], "bump"),
     };
     this.tex = {};
-    for (const [name, desc] of [...Object.entries(this.doc.textures), ...Object.entries(this.fonts.textures)]) {
-      if (this.tex[name]) throw new UIError(`texture name ${name} used twice`);
-      this.tex[name] = await GLTex.load(gl, this.dir, desc, assets);
+    for (const sprite of this.sprites.values()) {
+      const id = sprite.texture.id;
+      this.tex[id] = await this.objects.texture(id);
     }
+    for (const address of Object.keys(this.data.parts.assets || {})) {
+      if (!address.startsWith("Adv/Transition/")) continue;
+      const s = this.rule.settings(address.slice("Adv/Transition/".length));
+      if (s.texture) this.tex[s.texture] = await this.objects.texture(s.texture);
+    }
+    for (const [name, desc] of Object.entries(this.fonts.textures))
+      this.tex[name] = await GLTex.load(gl, this.dir, desc, assets);
     for (const g of this._fonts.browserFonts().values()) this.tex[g.page] = g.texture(gl);   // pages of browser fonts
     this.materials = {};
-    this._addMaterials(new Map(Object.entries(this.doc.materials)), this.doc.materialKeywords);
+    this._addMaterials(this.uiMaterials);
     this._addMaterials(new Map(Object.entries(this.fonts.materials)), this.fonts.materialKeywords);
     this._addMaterials(this._materialInstances, this.fonts.materialKeywords);
     this.buf = { vao: gl.createVertexArray(), vbo: gl.createBuffer(), ibo: gl.createBuffer() };
@@ -378,12 +385,13 @@ export class StoryUI {
   }
 
   // GL material records (compiled up front); an instance takes the keywords of its base material
-  _addMaterials(mats, keywords) {
+  _addMaterials(mats, keywords = {}) {
     if (!this.gl) return;
     for (const [name, m] of mats) {
-      const shader = m.shader.shader, defaults = this.lib.defaults(shader, this.solid);
+      const shader = typeof m.shader === "string" ? m.shader : this.fonts.shaders[m.shader.shader];
+      const defaults = this.lib.defaults(shader, this.solid);
       const num = Object.fromEntries(Object.entries(defaults).filter(([, v]) => typeof v === "number"));
-      const kw = keywords[m.baseName || name] || [];
+      const kw = keywords[m.baseName || name] || m.keywords || [];
       this.materials[name] = { shader, keywords: kw, floats: { ...num, ...m.floats }, colors: m.colors || {}, defaults };
       this.lib.program(shader, 0, kw);                                   // compile up front
     }
@@ -458,7 +466,7 @@ export class StoryUI {
     let mesh = UIImage.build(n, img, sp, this.scaler.m_ReferencePixelsPerUnit);
     if (n.gradient) mesh = UIGradientMod.apply(mesh, n.gradient);
     return { node: n, kind: n === this.part.rule ? "rule" : "image", material: img.material,
-             texture: sp ? sp.texture.name : null, verts: UIDraw.pack(mesh.verts, n, alpha),
+             texture: sp ? sp.texture.id : null, verts: UIDraw.pack(mesh.verts, n, alpha),
              idx: Uint32Array.from(mesh.idx), mesh };
   }
 
@@ -602,9 +610,8 @@ export class StoryUI {
   // Fwk.UI.UIWidget.TrueCanvasSortOrder: the sorting order of the widget's first canvas (_canvases[0]), 99999 without
   // canvases; null when the UI data does not carry the widget's canvas list (ui.json `widget`)
   get trueCanvasSortOrder() {
-    const w = this.doc.widget;
-    if (!w || !Array.isArray(w.canvases)) return null;
-    return w.canvases.length ? w.canvases[0].sortingOrder : 99999;
+    const p = this.objects.prefab(this.doc.widget), w = p.find("UIAdvWidget").c.fields;
+    return w._canvases.length ? p.componentOf(w._canvases[0], "Canvas").fields.m_SortingOrder : 99999;
   }
 
   // ------------------------------------------------------------ StoryUI: talk window
@@ -735,7 +742,7 @@ export class StoryUI {
     const a = cg.alpha;
     if (Math.abs(1 - a) < Math.max(F(Math.max(Math.abs(a), 1) * 1e-6), F(1.401298464324817e-45 * 8))) return;
     this._backdropFade = new UITween(this.tweens, { duration: BACKDROP_FADE, getFrom: () => cg.alpha, to: 1,
-                                                    ease: this.doc.dotween.defaultEaseType, apply: (v) => { cg.alpha = v; } });
+                                                    ease: this.dotween.defaultEaseType, apply: (v) => { cg.alpha = v; } });
   }
 
   // UIAdvWidget.ResetAdvBlurAndBackdrop: DisposeAdvBlurScope, backlog not shown, DOKill on the backdrop CanvasGroup
@@ -789,7 +796,7 @@ export class StoryUI {
       this.setActive(f, false);
       resolve();
     };
-    const tw = new UITween(this.tweens, { duration, getFrom: () => color.a, to: 0, ease: this.doc.dotween.defaultEaseType,
+    const tw = new UITween(this.tweens, { duration, getFrom: () => color.a, to: 0, ease: this.dotween.defaultEaseType,
                                           apply: (v) => { color.a = v; }, onComplete: end });
     rec.kill = () => { tw.kill(); end(); };
     this._flash = rec;
@@ -847,9 +854,9 @@ export class StoryUI {
 
   // PauseVideoButton.ChangeNormalState: the ButtonImageState target shows the normal sprite
   resetPauseVideoButton() {
-    const b = this._need("pauseVideoButton", "pause video button"), st = b.rec.buttonImageState;
+    const b = this._need("pauseVideoButton", "pause video button"), st = b.fields("ButtonImageState");
     if (!st) throw new UIError(`${b.path}: no ButtonImageState`);
-    const target = this.nodes.get(st.target), sp = this.sprites.get(st.normal);
+    const target = b.ref(st._target), sp = this.sprite(st._normaledSprite);
     if (!target || !target.image || !sp) throw new UIError(`${b.path}: ButtonImageState target or sprite not in the data`);
     target.image.spriteObj = sp;
   }
@@ -876,12 +883,12 @@ export class StoryUI {
   // advances by _duration when > 0; timeScale = the view's playback speed), Play, then WaitWhile(IsPlaying) at
   // PlayerLoopTiming.Update. The CustomEvent of both views calls SimpleAnimationTrigger.PlayAnimation("Play").
   _playSequence(node) {
-    const ts = node.rec.tweenSequence;
-    if (!ts || ts.raw.updateType !== 0 || ts.raw.isSpeedBased) throw new UIError(`${node.path}: DOTweenSequence settings`);
+    const ts = node.fields("DOTweenSequence");
+    if (!ts || ts.updateType !== 0 || ts.isSpeedBased) throw new UIError(`${node.path}: DOTweenSequence settings`);
     if (node.sequence) { node.sequence.kill(); node.sequence = null; }
     let at = 0;
     const at0 = [];
-    for (const cmd of ts.list) {
+    for (const cmd of ts._list) {
       if (cmd._commandType !== 1 || at !== 0) throw new UIError(`${node.path}: sequence command outside the implemented subset`);
       at0.push(() => this._playAnimation(node, "Play"));
       if (cmd._duration > 0) at += cmd._duration;
diff --git a/tests/data/story-data.test.mjs b/tests/data/story-data.test.mjs
index fedacb2..e2bd086 100644
--- a/tests/data/story-data.test.mjs
+++ b/tests/data/story-data.test.mjs
@@ -5,17 +5,17 @@
 //   OURNOTES_STORY_IDS=<id>,...|all    the stories loaded per language (default: the first three of stories.json); an
 //                                      id is the manifest path below stories/ without .json (10462, tw/10462)
 //
-// Checks: scripts/validate-data.mjs passes every story of the site; per chosen story and language, loadStoryStore
-// (src/story/assets.js) with a file fetch holds exactly the common files, that language's files and, under
-// live2d/<id>/, the files of the models the manifest lists, with their manifest sizes; the paths story.json names
-// resolve in it (each model's through its model.json), and ui/fonts.json and ui/languages.json are of that language.
-// The stories whose required commands this player lacks are reported (a diagnostic, not a failure).
+// Checks: the site validator accepts each story product; the selected stories load every language with exactly
+// their part files and shared object roles. File sizes, model references, UI and font languages agree with the graph.
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { test } from "node:test";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { StoryData } from "../../src/story/data.js";
+import { storyPartRequests } from "../../src/story/store.js";
+import { mergeProductManifests, productDir } from "../../src/data/products.js";
 import { modelIndex } from "../../src/live2d/model.js";
 import { fetchStoryManifest, loadStoryStore } from "../../src/story/assets.js";
 import { nodeDecode } from "../../scripts/lib/headless.mjs";
@@ -55,33 +55,32 @@ test("the validator passes every story of the site", { skip: SKIP }, () => {
 });
 
 for (const e of chosen()) {
-  test(`story ${idOf(e.manifest)}: every language through loadStoryStore`, async (t) => {
+  test(`story ${idOf(e.manifest)}: every language through loadStoryStore`, async () => {
     const url = pathToFileURL(path.join(SITE, e.manifest)).href;
-    const man = JSON.parse(fs.readFileSync(path.join(SITE, e.manifest), "utf8"));
-    try { await fetchStoryManifest(url, { fetch: fileFetch }); }
-    catch (err) { t.diagnostic(`refused by this player: ${err.message}`); }
-    for (const lang of Object.keys(man.languages)) {
-      const store = await loadStoryStore(url, { lang, fetch: fileFetch, manifest: { url, manifest: man }, decode: nodeDecode });
-      const files = { ...man.files, ...man.languages[lang].files };
-      const root = path.resolve(path.dirname(path.join(SITE, e.manifest)), man.root);
-      for (const [id, p] of Object.entries(man.models)) {
-        const mm = JSON.parse(fs.readFileSync(path.join(root, p), "utf8"));
-        for (const [f, entry] of Object.entries(mm.files)) files[`live2d/${id}/${f}`] = entry;
+    const head = await fetchStoryManifest(url, { fetch: fileFetch, decode: nodeDecode });
+    for (const lang of Object.keys(head.story.parts.ui)) {
+      const store = await loadStoryStore(url, { lang, fetch: fileFetch, manifest: head, decode: nodeDecode });
+      const products = [[`stories/${head.story.advId}`, head.manifest]];
+      for (const [file] of storyPartRequests(head.story, lang)) {
+        const manifest = JSON.parse(fs.readFileSync(new URL(file, head.root), "utf8"));
+        products.push([productDir(file), manifest]);
       }
-      assert.deepEqual(store.list().sort(), Object.keys(files).sort(), `${lang}: the store's files`);
-      for (const [p, f] of Object.entries(files)) {
-        const size = /\.(json|glsl)$/.test(p) ? Buffer.byteLength(store.text(p)) : store.bytes(p).byteLength;
-        assert.equal(size, f.size, `${lang}: ${p}`);
+      const expected = mergeProductManifests(products);
+      assert.deepEqual(store.list().sort(), Object.keys(expected.files).sort(), `${lang}: the store's files`);
+      for (const [p, f] of Object.entries(expected.files)) assert.equal(store.bytes(p).byteLength, f.size, `${lang}: ${p}`);
+      for (const [id, object] of Object.entries(expected.objects)) {
+        assert.equal(store.object(id).class, object.class);
+        for (const [role, f] of Object.entries(object.files)) assert.equal(store.objectBytes(id, role).byteLength, f.size, `${lang}: ${id}#${role}`);
       }
-      const story = store.json("story.json");
-      for (const p of [story.episode, story.scene, story.ui]) assert.ok(store.has(p), `${lang}: ${p}`);
-      for (const [key, id] of Object.entries(story.models)) {
-        const m = modelIndex(store, `live2d/${id}`);                     // its objects checked by class
+      const data = new StoryData(store);
+      assert.equal(data.episode.advId, head.story.advId);
+      for (const key of Object.keys(data.parts.models)) {
+        const m = modelIndex(store, data.model(key).dir);
         assert.ok(store.roles(m.moc).includes("blob:_bytes"), `${lang}: ${key}: the moc's bytes`);
       }
-      for (const dir of Object.values(story.audio)) assert.ok(store.has(`${dir}/cues.json`), `${lang}: ${dir}/cues.json`);
-      assert.equal(store.json("ui/fonts.json").language, lang);
-      assert.equal(store.json("ui/languages.json").language, lang);
+      for (const sheet of Object.keys(data.parts.sounds)) assert.ok(data.cues(sheet), `${lang}: ${sheet}`);
+      assert.equal(data.fonts.language, lang);
+      assert.equal(data.ui.language.code, lang);
       assert.equal(store.info.loadedLanguage, lang);
     }
   });
diff --git a/tests/data/story-feature.test.mjs b/tests/data/story-feature.test.mjs
index c0f530c..8839934 100644
--- a/tests/data/story-feature.test.mjs
+++ b/tests/data/story-feature.test.mjs
@@ -2,18 +2,16 @@
 // particles, videos, chat, ...) through StorySession in Node (gl = null: nothing is drawn, no sound is played), with
 // Live2D Cubism Core. Every row of the episodes runs, the feature commands included.
 //
-//   OURNOTES_STORY_DIRS=<dir>,<dir>,...   story directories (story.json, episode.json, scene.json, ...; the models in
-//                                         story.json modelsDir); or
-//   OURNOTES_STORY_ROOT=<dir> [OURNOTES_STORY_IDS=<id>,<id>,...]   a directory of story directories named by ADV id
+//   OURNOTES_STORY_DIRS=<dir>,<dir>,...   story product manifests or single-story product layouts; or
+//   OURNOTES_STORY_ROOT=<dir> [OURNOTES_STORY_IDS=<id>,<id>,...]   a product layout with stories/<id>.json
 //                                         (all of them without OURNOTES_STORY_IDS); skipped without either
 //   CUBISM_CORE=<file>                    Live2D's live2dcubismcore.min.js (skipped without it; not in this repository)
 //   MOTIONSYNC_CORE=<file>                Live2D's MotionSync Core (optional)
 //   OURNOTES_STORY_TRACE=<dir>            writes <id>.json (feature command trace, state hashes) per episode
 //   OURNOTES_STORY_TIMEOUT=<seconds>      time limit per episode (both runs), default 3600
 //
-// A story directory without the story UI's font data (ui/fonts.json), or any with OURNOTES_STORY_STAND_IN_UI=1, plays
-// with a timing-only stand-in for the story UI (every UI call completes at once, text reveals at once): the feature
-// commands and the scene still run exactly.
+// OURNOTES_STORY_STAND_IN_UI=1 selects a timing-only stand-in for the story UI; otherwise the product's UI and fonts
+// are used. OURNOTES_STORY_LANG selects the language (ja by default).
 // Checks per episode: it plays to its end in auto mode; every feature command it uses ran; two runs with the same seed
 // give the same trace and the same per-frame feature state.
 import assert from "node:assert/strict";
@@ -22,15 +20,16 @@ import fs from "node:fs";
 import path from "node:path";
 import vm from "node:vm";
 import { test } from "node:test";
-import { storyDirStore } from "../../scripts/lib/headless.mjs";
+import { openStory } from "../../scripts/lib/headless.mjs";
+import { StoryData } from "../../src/story/data.js";
 import { createStoryUILayers } from "../../src/story/interfaces.js";
 
 const CORE = process.env.CUBISM_CORE || "", MS = process.env.MOTIONSYNC_CORE || "";
 const ROOT = process.env.OURNOTES_STORY_ROOT || "";
+const LANG = process.env.OURNOTES_STORY_LANG || "ja";
 const DIRS = process.env.OURNOTES_STORY_DIRS ? process.env.OURNOTES_STORY_DIRS.split(",").map((s) => s.trim()).filter(Boolean)
-  : ROOT ? (process.env.OURNOTES_STORY_IDS ? process.env.OURNOTES_STORY_IDS.split(",").map((s) => s.trim())
-    : fs.readdirSync(ROOT).filter((n) => fs.existsSync(path.join(ROOT, n, "story.json"))).sort()).map((n) => path.join(ROOT, n))
-    : [];
+  : ROOT ? (process.env.OURNOTES_STORY_IDS ? process.env.OURNOTES_STORY_IDS.split(",").map((id) => `${id}.json`)
+    : fs.readdirSync(path.join(ROOT, "stories")).filter((n) => n.endsWith(".json")).sort()).map((n) => path.join(ROOT, "stories", n)) : [];
 const SKIP = !DIRS.length ? "OURNOTES_STORY_DIRS / OURNOTES_STORY_ROOT is not set"
   : !CORE ? "CUBISM_CORE is not set (path of Live2D's live2dcubismcore.min.js)" : false;
 const OUT = process.env.OURNOTES_STORY_TRACE || "";
@@ -88,12 +87,12 @@ const run = async (dir, { seed = 1, maxFrames = 30 * 60 * 40 } = {}) => {
   const { StorySession } = await import("../../src/story/session.js");
   const features = await import("../../src/story/features/index.js");
   const names = new Set(await FEATURE_NAMES());
-  const store = storyDirStore(dir);
+  const store = await openStory(dir, { lang: LANG });
   const trace = [], states = [];
   let s = null;
   s = await StorySession.create(null, store, {
     seed, auto: true, sound: false, autoplay: true,
-    ui: !STAND_IN && store.has("ui/fonts.json") ? undefined : standInUI(),
+    ui: STAND_IN ? standInUI() : undefined,
     onCommand: (c) => { if (names.has(c.cmd)) trace.push(`${s ? s.frame : 0} #${c.i} ${c.cmd}`); },
   });
   for (let n = 0; !s.ended && n < maxFrames; n++) {
@@ -113,7 +112,7 @@ const T = { skip: SKIP, timeout: TIMEOUT_S * 1000 };
 
 for (const dir of DIRS) {
   test(`story features: ${path.basename(dir)} plays to its end, deterministically`, T, async () => {
-    const episode = JSON.parse(fs.readFileSync(path.join(dir, "episode.json"), "utf8"));
+    const episode = new StoryData(await openStory(dir, { lang: LANG })).episode;
     const names = new Set(await FEATURE_NAMES());
     const used = [...new Set(episode.commands.filter((c) => !c.IgnoreData && names.has(c.cmd)).map((c) => c.cmd))].sort();
     const a = await run(dir, { seed: 7 }), b = await run(dir, { seed: 7 });
diff --git a/tests/data/story-play.test.mjs b/tests/data/story-play.test.mjs
index bc0fde6..619fc77 100644
--- a/tests/data/story-play.test.mjs
+++ b/tests/data/story-play.test.mjs
@@ -2,9 +2,7 @@
 // Cubism Core and, when given, Live2D's MotionSync Core. The whole story runs: interpreter, camera and field, the
 // Live2D characters (load, warmup, frames), the story UI's timing and layout.
 //
-//   OURNOTES_STORY=<path>       a story manifest of a site (stories/<advId>.json), or a directory with a story's logical
-//                               files (story.json, episode.json, scene.json, ...; its models in story.json modelsDir);
-//                               skipped without it
+//   OURNOTES_STORY=<path>       a story product manifest, or a product layout containing exactly one story
 //   OURNOTES_STORY_LANG=<lang>  the language to load from a manifest (default: the manifest's)
 //   CUBISM_CORE=<file>          Live2D's live2dcubismcore.min.js (skipped without it; not part of this repository)
 //   MOTIONSYNC_CORE=<file>      Live2D's live2dcubismmotionsynccore.min.js (optional: without it lip sync is missing)
diff --git a/tests/data/story-ui-layout.test.mjs b/tests/data/story-ui-layout.test.mjs
index 326f3ea..f3c4622 100644
--- a/tests/data/story-ui-layout.test.mjs
+++ b/tests/data/story-ui-layout.test.mjs
@@ -1,6 +1,6 @@
 // Opt-in: the story UI's layout and timing on a real story (the front canvas of one episode) in Node, no GL.
 //
-//   OURNOTES_STORY=<dir>              a story's logical files: episode.json, ui/ui.json, ui/fonts.json, ui/languages.json
+//   OURNOTES_STORY=<dir>              a story product manifest or a layout containing one story
 //                                     (skipped without it)
 //   OURNOTES_STORY_UI_LINES=<file>    optional: write the line breaks of every Talk line of the episode in the talk text
 //                                     (JSON: per Talk row the text of each laid-out line), e.g. to compare font sets
@@ -16,7 +16,9 @@
 // speaker name 樂奈 (quad, padded atlas rect, preferred width) is checked as well.
 import assert from "node:assert/strict";
 import fs from "node:fs";
-import path from "node:path";
+import { openStory } from "../../scripts/lib/headless.mjs";
+import { StoryData } from "../../src/story/data.js";
+import { ObjectResources } from "../../src/engine/objects.js";
 import { test } from "node:test";
 import { F } from "../../src/engine/core.js";
 import { PlayerLoop } from "../../src/engine/loop.js";
@@ -25,12 +27,12 @@ import { countedText } from "../../src/story/ui-ruby.js";
 import { countRenderedCharacters, removeTagsWithRuby } from "../../src/story/ui-talk.js";
 
 const DIR = process.env.OURNOTES_STORY || "", LINES = process.env.OURNOTES_STORY_UI_LINES || "";
-const SKIP = DIR ? false : "OURNOTES_STORY is not set (path of a story directory)";
-const readJSON = (f) => JSON.parse(fs.readFileSync(path.join(DIR, f), "utf8"));
+const SKIP = DIR ? false : "OURNOTES_STORY is not set (path of a story product manifest)";
 
 test("story UI layout and timing", { skip: SKIP }, async () => {
-  const doc = readJSON("ui/ui.json"), fonts = readJSON("ui/fonts.json"), language = readJSON("ui/languages.json");
-  const episode = readJSON("episode.json");
+  const assets = await openStory(DIR, { lang: process.env.OURNOTES_STORY_LANG || "ja" }), data = new StoryData(assets);
+  const doc = data.ui, fonts = data.fonts, language = doc.language, episode = data.episode;
+  const objects = new ObjectResources(assets, data.resourceOptions());
   const field = language.field;
   const txt = (id) => episode.text[id][field];
   const talks = episode.commands.filter((c) => c.cmd === "Talk" && c.AdvTextID && c.AdvTextID !== "0");
@@ -55,7 +57,7 @@ test("story UI layout and timing", { skip: SKIP }, async () => {
   };
 
   const loop = new PlayerLoop(30);
-  const ui = new StoryUI(null, loop, doc, { lang: language.language, fonts, language });
+  const ui = new StoryUI(null, loop, doc, { data, objects, assets });
   ui.setTalkWindow("UIDefaultTalkWindow");
   const D = ui.windows.get("UIDefaultTalkWindow").part;                // the default window's parts with the widget's
   const P = { ...ui.part, ...D, speakerBack: D.speaker.find("Back") }, tt = P.talkText.text;
@@ -180,7 +182,7 @@ test("story UI layout and timing", { skip: SKIP }, async () => {
   ui.setAutoMode(false);
 
   // --- rule fade: FadeIn 1.0 s with the default transition; shader alpha = smoothstep(clamp01((1 - Val) / 2)) -------------
-  const ts = ui.transitionSettings(doc.playerSettings._defaultTransitionAssetAddress);
+  const ts = ui.transitionSettings(data.playerSettings._defaultTransitionAssetAddress);
   const f0 = loop.frameCount;
   let ruleHiddenAt = -1, val15 = null;
   const fade = ui.fadeIn(ts, { r: 0, g: 0, b: 0, a: 1 }, 1.0).then(() => { ruleHiddenAt = loop.frameCount - f0; });
@@ -252,7 +254,7 @@ test("story UI layout and timing", { skip: SKIP }, async () => {
       P.talkText.storyText.setText(s); tt.setMaxVisible(99999); tt.generate();
       out[c.i] = tt.lines.map((ln) => tt.chars.slice(ln.first, ln.last + 1).map((ch) => String.fromCodePoint(ch.u)).join(""));
     }
-    fs.writeFileSync(LINES, `${JSON.stringify({ language: language.language, source: fonts.source, lines: out }, null, 1)}\n`);
+    fs.writeFileSync(LINES, `${JSON.stringify({ language: language.code, source: fonts.source, lines: out }, null, 1)}\n`);
   }
 
   // --- table ------------------------------------------------------------------------------------------------------------
diff --git a/tests/unit/crilips-frontend.test.mjs b/tests/unit/crilips-frontend.test.mjs
index 7c0b197..a14108d 100644
--- a/tests/unit/crilips-frontend.test.mjs
+++ b/tests/unit/crilips-frontend.test.mjs
@@ -187,14 +187,13 @@ test("analyzer: shared readers in one frame and a paused voice keep the last val
   assert.equal(a.getOpenInfo().openY, last);
 });
 
-test("story voice hook: one analyzer per voice from story.json crilips, the voice's PCM without it", async () => {
+test("story voice hook: one analyzer per voice from the CRI Lips product, the voice's PCM without it", async () => {
   const { startVoiceLipSync } = await import("../../src/story/commands/talk.js");
   const { CriLipsAnalyzer } = await import("../../src/live2d/crilips/index.js");
   const { desc, blob } = synthParts();
   const session = (crilips) => {
     const src = { sampleRate: 48000, pull: () => new Float32Array(0) };
-    const p = { ctx: { story: { crilips }, audio: { pcmSource: () => src },
-                       assets: { json: () => desc, arrayBuffer: () => blob.buffer.slice(0) } },
+    const p = { ctx: { data: { crilips }, audio: { pcmSource: () => src } },
                 session: { activeVoiceLipSync: new Map(), motionSyncVoices: new Map() } };
     const character = () => {
       const c = { isMotionSyncEnabled: false, analyzer: undefined, setLipSyncPresentationMode() {}, setLipSyncEnabled() {} };
@@ -203,7 +202,7 @@ test("story voice hook: one analyzer per voice from story.json crilips, the voic
     };
     return { p, src, character };
   };
-  const on = session({ descriptor: "crilips/crilips.json", data: "crilips/crilips.bin" });
+  const on = session({ descriptor: desc, data: blob.buffer.slice(0) });
   const info = { id: 1 }, a = on.character(), b = on.character();
   startVoiceLipSync(on.p, a, info, false);
   startVoiceLipSync(on.p, b, info, false);
diff --git a/tests/unit/engine-audio.test.mjs b/tests/unit/engine-audio.test.mjs
index 835604f..70942dd 100644
--- a/tests/unit/engine-audio.test.mjs
+++ b/tests/unit/engine-audio.test.mjs
@@ -2,7 +2,7 @@
 // a voice played time-stretched and the movie bus of the videos' sound; engine/timestretch.js on synthetic PCM.
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { Audio, playbackSpeed } from "../../src/engine/audio.js";
+import { Audio, SOUND_CATEGORY, busOf, playbackSpeed } from "../../src/engine/audio.js";
 import { timeStretch } from "../../src/engine/timestretch.js";
 
 const F = Math.fround;
@@ -16,7 +16,7 @@ const fakeContext = () => {
   };
   return {
     sampleRate: 48000, currentTime: 0, state: "running", destination: {},
-    createGain() { return { gain: param(1), connect(n) { return n; } }; },
+    createGain() { return { gain: param(1), to: null, connect(n) { this.to = n; return n; } }; },
     createMediaElementSource(el) {
       const n = { el, to: null, connect(x) { n.to = x; return x; }, disconnect() { n.to = null; } };
       this.media.push(n);
@@ -47,6 +47,26 @@ test("playbackSpeed: [0.25, 3], within max(|s|, 1) x 1e-6 of 1 plays as is", ()
   assert.throws(() => playbackSpeed(NaN), /outside/);
 });
 
+test("episode sound preload uses the cue product's resolved waveform path", async () => {
+  const meta = { file: "sounds/sheet-a/waveforms/voice.flac", sampleRate: 48000, samples: 48000, categories: ["Voice"] };
+  const episode = { sounds: { 7: { _soundCueSheetID: 3, _cueName: "hello", _category: 0 } },
+    cuesheets: { 3: { _cueSheetName: "sheet-a" } } };
+  const reads = [], context = fakeContext();
+  context.decodeAudioData = async () => context.buffer(1, 48000, 48000);
+  const resolve = Audio.episodeResolver(episode, { cues: (name) => {
+    assert.equal(name, "sheet-a"); return { hello: meta };
+  } });
+  const audio = new Audio(resolve, { time: 0 }, { context, assets: {
+    arrayBuffer: (path) => { reads.push(path); return new ArrayBuffer(0); },
+  } });
+  await audio.preload([7, 7]);
+  assert.deepEqual(reads, [meta.file]);
+  assert.equal(audio.buffers.get("sheet-a/hello").meta, meta);
+  const id = audio.play(7);
+  assert.equal(audio.get(id).gain.to, audio.buses[SOUND_CATEGORY.Voice]);
+  assert.equal(audio.get(id).category, SOUND_CATEGORY.Bgm);
+});
+
 test("option volumes multiply the category bus; All scales by DefaultVolume, a name sets it as is", () => {
   const ctx = fakeContext();
   const a = new Audio(() => null, { time: 0 }, { context: ctx });
@@ -65,6 +85,28 @@ test("option volumes multiply the category bus; All scales by DefaultVolume, a n
   assert.ok(Number.isNaN(a.getOptionVolume("Nope")));
 });
 
+test("a cue plays on the bus of its sheet's CRI categories; its row's category decides what stopAll reaches", () => {
+  const ctx = fakeContext(), loop = { time: 0 };
+  const cue = { sheet: "s", cue: "c", category: SOUND_CATEGORY.Bgm, row: {} };     // a voice cue whose row says Bgm
+  const a = new Audio(() => cue, loop, { context: ctx });
+  const put = (categories) => a.buffers.set("s/c", { buf: ctx.buffer(1, 48000, 48000),
+    meta: { sampleRate: 48000, samples: 48000, ...(categories ? { categories } : {}) } });
+  put(["Voice", "VoiceConfig"]);
+  const voice = a.get(a.play(1, { crossFade: 0 }));
+  put(null);
+  const row = a.get(a.play(1, { crossFade: 0 }));
+  assert.deepEqual([voice.gain.to === a.buses[SOUND_CATEGORY.Voice], row.gain.to === a.buses[SOUND_CATEGORY.Bgm]], [true, true]);
+  assert.deepEqual([voice.category, row.category], [SOUND_CATEGORY.Bgm, SOUND_CATEGORY.Bgm]);
+  a.stopAll(SOUND_CATEGORY.Bgm);
+  assert.deepEqual([a.isPlaying(voice.id), a.isPlaying(row.id)], [false, false]);
+  a.setOptionVolume("Bgm", 0);
+  put(["Voice", "VoiceConfig"]);
+  a.play(1, { crossFade: 0 });
+  assert.equal(a.buses[SOUND_CATEGORY.Voice].gain.value, 1);
+  assert.equal(busOf({ categories: ["Other", "Se"] }, SOUND_CATEGORY.Bgm), SOUND_CATEGORY.Se);
+  assert.equal(busOf({ categories: ["Other"] }, SOUND_CATEGORY.Voice), SOUND_CATEGORY.Voice);
+});
+
 test("a video's sound: on the movie bus at the movie volume, which no category or option volume changes", () => {
   const ctx = fakeContext();
   const a = new Audio(() => null, { time: 0 }, { context: ctx });
diff --git a/tests/unit/engine-postfx.test.mjs b/tests/unit/engine-postfx.test.mjs
index 3e34a65..0d4dad3 100644
--- a/tests/unit/engine-postfx.test.mjs
+++ b/tests/unit/engine-postfx.test.mjs
@@ -318,11 +318,11 @@ test("film grain: renderer textures by type, a custom texture, none without text
   const tiling = g.v("_Grain_TilingParams");
   assert.deepEqual(tiling.slice(0, 2), [1280 / 256, 720 / 256]);
   assert.deepEqual(tiling.slice(2), URPPost.grainOffsets(7));
-  const desc = { texture: "textures/custom.png", name: "custom", width: 64, height: 32, mipCount: 1 };
+  const desc = { $ref: { file: "texture", pathId: "1" } };
   assert.ok(!uberOf([P("FilmGrain", { type: 10, intensity: 1 })]).b.keywords.includes("_FILM_GRAIN"));
-  assert.throws(() => uberOf([P("FilmGrain", { type: 10, intensity: 1, texture: desc })]), /custom not loaded/);
+  assert.throws(() => uberOf([P("FilmGrain", { type: 10, intensity: 1, texture: desc })]), /texture:1 not loaded/);
   const r = rig(), custom = r.tex(64, 32, "custom");
-  r.post.volumeTextures.set(desc.texture, custom);
+  r.post.volumeTextures.set("texture:1", custom);
   r.post.uber(URPPost.evaluateStack([vol([P("FilmGrain", { type: 10, intensity: 1, texture: desc })])]), r.src, r.o.black, r.dst, r.o);
   assert.equal(r.blits[0].value("_Grain_Texture"), custom);
   assert.deepEqual(r.blits[0].value("_Grain_TilingParams").slice(0, 2), [20, 22.5]);
@@ -346,16 +346,17 @@ test("film grain: the tiling follows the game camera's pixels (grainScale), grai
 test("loadVolumeTextures loads the overridden texture parameters once, with the uber pass's samplers", async () => {
   const r = rig();
   const images = [];
-  const assets = { image: async (p) => { images.push(p); return { width: 64, height: 32, close() {} }; } };
-  const desc = { texture: "textures/custom.png", name: "custom", width: 64, height: 32, mipCount: 1,
-                 settings: { m_FilterMode: 0, m_WrapU: 1, m_WrapV: 1 } };
+  const desc = { $ref: { file: "texture", pathId: "1" } };
+  const objects = { id: (v) => `${v.$ref.file}:${v.$ref.pathId}`, texture: async (id) => {
+    images.push(id); return r.tex(64, 32, id);
+  } };
   const prof = { components: [P("FilmGrain", { type: 10, intensity: 1, texture: desc }),
-                              { asset: "Bloom", active: 1, dirtTexture: { m_OverrideState: 0, m_Value: { ...desc, texture: "textures/dirt.png" } } }] };
+    { asset: "Bloom", active: 1, dirtTexture: { m_OverrideState: 0, m_Value: { $ref: { file: "texture", pathId: "2" } } } }] };
   r.calls.length = 0;
-  await r.post.loadVolumeTextures("base", [prof, prof], assets);
+  await r.post.loadVolumeTextures([prof, prof], objects);
   assert.equal(images.length, 1);
-  assert.ok(r.post.volumeTextures.has("textures/custom.png"));
-  assert.ok(!r.post.volumeTextures.has("textures/dirt.png"));
+  assert.ok(r.post.volumeTextures.has("texture:1"));
+  assert.ok(!r.post.volumeTextures.has("texture:2"));
   const params = r.calls.filter((c) => c.name === "texParameteri").map((c) => c.args.slice(1));
   assert.deepEqual(params.slice(-4), [[r.gl.TEXTURE_MAG_FILTER, r.gl.LINEAR], [r.gl.TEXTURE_MIN_FILTER, r.gl.LINEAR],
                                       [r.gl.TEXTURE_WRAP_S, r.gl.REPEAT], [r.gl.TEXTURE_WRAP_T, r.gl.REPEAT]]);
diff --git a/tests/unit/live2d-model.test.mjs b/tests/unit/live2d-model.test.mjs
index 31e9d77..e66de11 100644
--- a/tests/unit/live2d-model.test.mjs
+++ b/tests/unit/live2d-model.test.mjs
@@ -53,22 +53,24 @@ test("modelIndex: model.json at the store's root or in a directory, the classes
   assert.throws(() => modelIndex(o.store(model), "live2d/none"), /live2d\/none\/model\.json/);
 });
 
-test("storyModels: a model id names the model.json under live2d/<id>/; one model and ShaderLib per id", () => {
+test("storyModels: product directories share one model and shader library", () => {
   const gl = headlessGL();
   const { o, model } = objects();
-  const s = o.store({ dir: "live2d/m1", ...model });
-  const story = { models: { "Character/Live2D/g/a/model/a": "m1", "Character/Live2D/g/b/model/b": "m1",
-                            "Character/Live2D/g/c/model/c": "" } };
-  const modelOf = storyModels(gl, s, story, "story 7");
+  const assets = o.store({ dir: "models/m1", ...model });
+  const data = { assets, model: (address) => {
+    if (!["Character/Live2D/g/a/model/a", "Character/Live2D/g/b/model/b"].includes(address))
+      throw new Error(`story model ${address}: not listed`);
+    return { dir: "models/m1" };
+  } };
+  const modelOf = storyModels(gl, data);
   const a = modelOf("Character/Live2D/g/a/model/a");
-  assert.equal(a, modelOf("Character/Live2D/g/b/model/b"));      // one model (and ShaderLib) per id
-  assert.equal(a.id, "m1");
+  assert.equal(a, modelOf("Character/Live2D/g/b/model/b"));
+  assert.equal(a.id, "models/m1");
   assert.deepEqual(a.model, o.modelJson(model));
-  assert.equal(a.lib.info(LIT).name, LIT);                        // the ShaderLib of model.json shaders
-  assert.throws(() => modelOf("Character/Live2D/g/x/model/x"), /story 7: model Character\/Live2D\/g\/x\/model\/x is not in the story/);
-  assert.throws(() => modelOf("Character/Live2D/g/c/model/c"), /story 7: model Character\/Live2D\/g\/c\/model\/c is not in the story/);
-  const headless = storyModels(null, s, story, "story 7")("Character/Live2D/g/a/model/a");
-  assert.equal(headless.lib, null);                               // no GL: no shaders
+  assert.equal(a.lib.info(LIT).name, LIT);
+  assert.throws(() => modelOf("missing"), /story model missing: not listed/);
+  const headless = storyModels(null, data)("Character/Live2D/g/a/model/a");
+  assert.equal(headless.lib, null);
   assert.equal(headless.model.moc, model.moc);
 });
 
diff --git a/tests/unit/read-set.test.mjs b/tests/unit/read-set.test.mjs
index 308a214..e34ecd4 100644
--- a/tests/unit/read-set.test.mjs
+++ b/tests/unit/read-set.test.mjs
@@ -20,7 +20,7 @@ const script = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..
 
 // ---- synthetic note views
 const TRS = { localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 } };
-// a material record as LiveObjects.material gives it: the shader by name
+// a material record as ObjectResources.material gives it: the shader by name
 const mat = (name, shader = "Sprites/Default") => ({ material: name, shader, keywords: [], floats: { _Z: 1 }, colors: {} });
 const sprite = (name) => ({ sprite: name, texture: { texture: `textures/${name}.png` }, rect: { x: 0, y: 0, width: 4, height: 4 } });
 // references in prefab.json fields, resolved by the store stub below by their name
diff --git a/tests/unit/story-assets.test.mjs b/tests/unit/story-assets.test.mjs
index eecd329..ee3252f 100644
--- a/tests/unit/story-assets.test.mjs
+++ b/tests/unit/story-assets.test.mjs
@@ -1,158 +1,75 @@
-// Loading a story from a site (src/story/assets.js): the model manifests (product manifests of live2d.model) fetched,
-// their model.json merged under live2d/<id>/ and their objects into the store's object table, the site root from the
-// manifest's `root`; and the Node openers of scripts/lib/headless.mjs (a manifest on disk with encoded assets, a
-// story directory with its models directory). Synthetic sites only.
 import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { test } from "node:test";
 import { gzipSync } from "node:zlib";
-import { modelIndex } from "../../src/live2d/model.js";
-import { MODEL_PRODUCT, STORY_MANIFEST_FORMAT, STORY_MANIFEST_FORMATS, fetchStoryManifest, loadStoryStore }
-  from "../../src/story/assets.js";
-import { nodeDecode, openStory, storyDirStore } from "../../scripts/lib/headless.mjs";
-import { modelObjects, modelProduct, putFiles, sha256 } from "./site-fixture.mjs";
+import { STORY_MANIFEST_FORMAT, STORY_MANIFEST_FORMATS, fetchStoryManifest, loadStoryStore } from "../../src/story/assets.js";
+import { StoryData } from "../../src/story/data.js";
+import { nodeDecode, openStory } from "../../scripts/lib/headless.mjs";
+import { STORY_ROOT as ROOT, storyFixture } from "./story-product-fixture.mjs";
 
-const enc = new TextEncoder();
-const ROOT = "https://example.test/site/";
-const size = (s) => enc.encode(s).byteLength;
-
-// URL -> contents (string, bytes or JSON value); fetch records the requested URLs
-const site = (files) => {
-  const requested = [];
-  const fetch = async (u) => {
-    requested.push(String(u));
-    const v = files[String(u)];
-    if (v === undefined) return { ok: false, status: 404 };
-    const bytes = v instanceof Uint8Array ? v : enc.encode(typeof v === "string" ? v : JSON.stringify(v));
-    return { ok: true, status: 200, json: async () => JSON.parse(new TextDecoder().decode(bytes)),
-             arrayBuffer: async () => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) };
-  };
-  return { fetch, requested };
-};
-
-// a product manifest of model `id` whose model.json is `doc` (gzip-encoded with `gz`) and whose one object, a
-// Texture2D `oid` (default: one of its own), has a json file: [manifest, {URL: contents}]
-const product = (id, doc, { gz = false, oid = `CAB-${id}:1` } = {}) => {
-  const text = JSON.stringify(doc), z = new Uint8Array(gzipSync(enc.encode(text))), tj = JSON.stringify({ m_Name: oid });
-  const asset = `assets/${sha256(Buffer.from(text))}.json`, tasset = `assets/${sha256(Buffer.from(tj))}.json`;
-  const man = { schema: "nnnotes.product/1", product: MODEL_PRODUCT, subject: `Character/Live2D/g/${id}/model/${id}`,
-                files: { "model.json": gz ? { asset: `${asset}.gz`, size: size(text), stored: z.byteLength } : { asset, size: size(text) } },
-                objects: { [oid]: { class: "Texture2D", name: "t", files: { json: { asset: tasset, size: size(tj) } } } } };
-  return [man, { [`${ROOT}${gz ? `${asset}.gz` : asset}`]: gz ? z : text, [`${ROOT}${tasset}`]: tj }];
-};
-
-// a site of one region's story (stories/tw/7.json) using models m1 (its model.json gzip-encoded) and m2, which share
-// the object CAB-s:1
-const fixture = () => {
-  const story = JSON.stringify({ advId: 7, models: { "Character/Live2D/g/m1/model/m1": "m1", "Character/Live2D/g/m2/model/m2": "m2" } });
-  const [m1, f1] = product("m1", { name: "m1" }, { gz: true, oid: "CAB-s:1" }), [m2, f2] = product("m2", { name: "m2" }, { oid: "CAB-s:1" });
-  const man = {
-    format: STORY_MANIFEST_FORMAT, advId: 7, root: "../../", language: "en", story: { advId: 7, playbackMode: 0 },
-    requires: { commands: [] }, models: { m1: "models/m1.json", m2: "models/m2.json" },
-    files: { "story.json": { asset: "assets/story.json", size: size(story) } },
-    languages: { en: { files: { "ui/languages.json": { asset: "assets/en.json", size: 13 } } },
-                 ja: { files: { "ui/languages.json": { asset: "assets/ja.json", size: 13 } } } },
-  };
-  const files = {
-    [`${ROOT}stories/tw/7.json`]: man, [`${ROOT}models/m1.json`]: m1, [`${ROOT}models/m2.json`]: m2, ...f1, ...f2,
-    [`${ROOT}assets/story.json`]: story, [`${ROOT}assets/en.json`]: '{"lang":"en"}', [`${ROOT}assets/ja.json`]: '{"lang":"ja"}',
-  };
-  return { man, files, m1, m2 };
+const edit = (fixture, name, fn) => {
+  const value = JSON.parse(new TextDecoder().decode(fixture.files.get(name)));
+  fn(value);
+  fixture.files.set(name, new TextEncoder().encode(JSON.stringify(value)));
 };
 
-test("formats: story manifest /2; model manifests are products of live2d.model", () => {
-  assert.equal(STORY_MANIFEST_FORMAT, "ournotes.story-manifest/2");
+test("public story loader reads product manifests and reuses a fetched index", async () => {
+  const f = storyFixture(), progress = [];
+  assert.equal(STORY_MANIFEST_FORMAT, "nnnotes.product/1");
   assert.deepEqual(STORY_MANIFEST_FORMATS, [STORY_MANIFEST_FORMAT]);
-  assert.equal(MODEL_PRODUCT, "live2d.model");
+  const manifest = await fetchStoryManifest(`${ROOT}stories/7.json`, { fetch: f.fetch });
+  const store = await loadStoryStore(manifest.url, { manifest, lang: "ja", onProgress: (a, b) => progress.push([a, b]) });
+  const data = new StoryData(store);
+  assert.equal(data.episode.advId, 7);
+  assert.equal(data.model("Character/Live2D/g/m/model/m").dir, "models/m");
+  assert.equal(data.fontDir, "storyfonts/7_ja");
+  assert.equal(store.info.loadedLanguage, "ja");
+  assert.deepEqual(Object.keys(store.info.languages), ["ja", "en"]);
+  assert.equal(new Set(f.requested).size, f.requested.length);
+  assert.equal(progress.at(-1)[0], progress.at(-1)[1]);
 });
 
-test("the models' model.json merged under live2d/<id>/ and their objects into one table, every path from the manifest's root", async () => {
-  const { files } = fixture();
-  const { fetch, requested } = site(files);
-  const progress = [];
-  const store = await loadStoryStore(`${ROOT}stories/tw/7.json`, { fetch, onProgress: (a, b) => progress.push([a, b]) });
-  assert.deepEqual(store.list().sort(), ["live2d/m1/model.json", "live2d/m2/model.json", "story.json", "ui/languages.json"]);
-  assert.deepEqual(store.json("live2d/m1/model.json"), { name: "m1" });          // decoded by the player
-  assert.deepEqual(store.objectJson("CAB-s:1"), { m_Name: "CAB-s:1" });          // one object of both models
-  assert.equal(store.json("ui/languages.json").lang, "en");
-  assert.equal(store.info.loadedLanguage, "en");
-  assert.deepEqual(store.info.models, { m1: "models/m1.json", m2: "models/m2.json" });
-  assert.deepEqual(Object.keys(store.info.languages), ["en", "ja"]);
-  assert.equal(store.info.files, undefined);
-  assert.equal(store.info.objects, undefined);
-  // the region's manifest resolves against the site root (../../), not stories/
-  assert.ok(requested.includes(`${ROOT}models/m1.json`) && requested.includes(`${ROOT}models/m2.json`));
-  assert.ok(requested.filter((u) => u.includes("/assets/")).every((u) => u.startsWith(`${ROOT}assets/`)), requested.join("\n"));
-  const shared = `${ROOT}assets/${sha256(Buffer.from(JSON.stringify({ m_Name: "CAB-s:1" })))}.json`;
-  assert.equal(requested.filter((u) => u === shared).length, 1);              // a shared object's file fetched once
-  assert.equal(progress.at(-1)[0], progress.at(-1)[1]);
-  // the other language; an explicit base
-  assert.equal((await loadStoryStore(`${ROOT}stories/tw/7.json`, { fetch, lang: "ja" })).json("ui/languages.json").lang, "ja");
-  const moved = Object.fromEntries(Object.entries(files).map(([u, v]) => [u.startsWith(`${ROOT}stories/`) ? u.replace(ROOT, "https://cdn.example.test/m/") : u, v]));
-  const b = await loadStoryStore("https://cdn.example.test/m/stories/tw/7.json", { ...site(moved), base: ROOT });
-  assert.deepEqual(b.json("live2d/m1/model.json"), { name: "m1" });
+test("a relocated story manifest can resolve dependencies from an explicit root", async () => {
+  const f = storyFixture(), relocated = "https://cdn.example.test/story.json";
+  const fetch = (url, init) => f.fetch(String(url) === relocated ? `${ROOT}stories/7.json` : url, init);
+  const store = await loadStoryStore(relocated, { fetch, base: ROOT, lang: "ja" });
+  assert.equal(new StoryData(store).ui.language.code, "ja");
 });
 
-test("a model manifest missing or not a product of live2d.model, a model of another id, an object two models differ on", async () => {
-  const url = `${ROOT}stories/tw/7.json`;
-  const rejects = async (edit, re) => {
-    const f = fixture();
-    edit(f);
-    await assert.rejects(loadStoryStore(url, site(f.files)), re);
+test("story model products validate their subject and shared object contracts", async () => {
+  const reject = async (change, message) => {
+    const f = storyFixture(); change(f);
+    await assert.rejects(loadStoryStore(`${ROOT}stories/7.json`, { fetch: f.fetch, lang: "ja" }), message);
   };
-  await rejects((f) => { delete f.files[`${ROOT}models/m2.json`]; }, /models\/m2\.json: HTTP 404/);
-  await rejects((f) => { f.m2.product = "live2d.cubism"; }, /models\/m2\.json: not a model manifest \(nnnotes\.product\/1 of live2d\.model\)/);
-  await rejects((f) => { delete f.m2.objects; }, /models\/m2\.json: not a model manifest/);
-  await rejects((f) => { f.m2.subject = "Character/Live2D/g/m3/model/m3"; }, /model m3, the story names it m2/);
-  await rejects((f) => { f.m2.objects["CAB-s:1"].class = "Material"; }, /story 7: object CAB-s:1 differs between the manifests of its models/);
-  await rejects((f) => { f.man.files["live2d/m1/model.json"] = f.man.files["story.json"]; }, /live2d\/m1\/model\.json: live2d\/ holds the models' files/);
-  await rejects((f) => { delete f.man.root; }, /without root \/ models/);
-  const { man, files } = fixture();
-  man.format = "ournotes.story-manifest/1";
-  await assert.rejects(fetchStoryManifest(url, site(files)), /not a story manifest \(ournotes\.story-manifest\/2\)/);
+  await reject(f => f.files.delete("models/m.json"), /models\/m\.json: HTTP 404/);
+  for (const fn of [m => { m.product = "story"; }, m => { delete m.objects; }, m => { m.subject = "another"; }])
+    await reject(f => edit(f, "models/m.json", fn), /expected live2d.model product/);
+  await reject(f => {
+    const object = { class: "Texture2D", name: "shared", files: {} };
+    edit(f, "models/m.json", m => { m.objects["fixture:1"] = object; });
+    edit(f, "storyassets/a.json", m => { m.objects["fixture:1"] = { ...object, class: "Material" }; });
+  }, /fixture:1/);
 });
 
-// ------------------------------------------------------------------------------------------------ Node openers
-test("openStory: a manifest on disk with encoded assets (node:zlib), its models' objects loaded", async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ournotes-story-open-"));
+test("openStory loads encoded product files from disk", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "story-product-"));
   try {
-    const m = modelObjects("m1");
-    fs.mkdirSync(path.join(dir, "models"));
-    const mm = modelProduct(dir, m, "br");
-    assert.ok(Object.values(mm.objects).some((o) => Object.values(o.files).some((f) => f.asset.endsWith(".json.br"))));
-    fs.writeFileSync(path.join(dir, "models", "m1.json"), JSON.stringify(mm));
-    const sf = putFiles(dir, { "story.json": { advId: 7, models: { "Character/Live2D/g/m1/model/m1": "m1" }, pad: "q".repeat(200) } }, "gzip");
-    const lf = putFiles(dir, { "ui/languages.json": { language: "en" } });
-    fs.mkdirSync(path.join(dir, "stories", "tw"), { recursive: true });
-    const manifest = path.join(dir, "stories", "tw", "7.json");
-    fs.writeFileSync(manifest, JSON.stringify({ format: STORY_MANIFEST_FORMAT, advId: 7, root: "../../", language: "en",
-                                                story: { playbackMode: 0 }, requires: { commands: [] }, models: { m1: "models/m1.json" },
-                                                files: sf, languages: { en: { files: lf } } }));
-    const store = await openStory(manifest);
-    assert.deepEqual(modelIndex(store, "live2d/m1"), m.model);
-    assert.equal(store.prefab(m.model.prefab).nodes[0].name, "m1");
-    assert.equal(store.json("story.json").advId, 7);
-    assert.equal(typeof store.image, "function");
+    const f = storyFixture();
+    edit(f, "storyfonts/7_ja.json", m => {
+      const entry = m.files["fonts.json"], bytes = gzipSync(f.files.get(entry.asset));
+      f.files.set(`${entry.asset}.gz`, bytes); entry.asset += ".gz"; entry.stored = bytes.length;
+    });
+    for (const [file, bytes] of f.files) {
+      const target = path.join(dir, file); fs.mkdirSync(path.dirname(target), { recursive: true }); fs.writeFileSync(target, bytes);
+    }
+    const store = await openStory(path.join(dir, "stories", "7.json"), { lang: "ja" });
+    assert.equal(new StoryData(store).fonts.format, "nnnotes.story-fonts/1");
+    assert.equal(new StoryData(await openStory(dir, { lang: "ja" })).episode.advId, 7);
+    fs.writeFileSync(path.join(dir, "stories", "8.json"), "{}");
+    await assert.rejects(openStory(dir, { lang: "ja" }), /choose a story product manifest/);
     assert.equal(Buffer.from(await nodeDecode(gzipSync(Buffer.from("abc")), "gzip")).toString(), "abc");
     await assert.rejects(nodeDecode(Buffer.from("x"), "zstd"), /unknown content encoding/);
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 });
-
-test("storyDirStore: a story directory with its models directory mounted at live2d/", () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ournotes-story-dir-"));
-  try {
-    // DIR/story.json with modelsDir, the models in DIR/../live2d/<id>/; DIR's own live2d/ hidden
-    const sdir = path.join(dir, "out", "7"), mdir = path.join(dir, "out", "live2d", "m1");
-    fs.mkdirSync(path.join(sdir, "live2d", "stale"), { recursive: true });
-    fs.mkdirSync(mdir, { recursive: true });
-    fs.writeFileSync(path.join(sdir, "story.json"), JSON.stringify({ advId: 7, models: { "Character/Live2D/g/m1/model/m1": "m1" }, modelsDir: "../live2d" }));
-    fs.writeFileSync(path.join(sdir, "live2d", "stale", "model.json"), "{}");
-    fs.writeFileSync(path.join(mdir, "model.json"), JSON.stringify({ name: "m1" }));
-    const ds = storyDirStore(sdir);
-    assert.equal(ds.has("live2d/m1/model.json"), true);
-    assert.equal(ds.has("live2d/stale/model.json"), false);
-    assert.deepEqual(ds.list(), ["live2d/m1/model.json", "story.json"]);
-  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-});
diff --git a/tests/unit/story-author.test.mjs b/tests/unit/story-author.test.mjs
index fd93ab2..ed7863b 100644
--- a/tests/unit/story-author.test.mjs
+++ b/tests/unit/story-author.test.mjs
@@ -13,7 +13,10 @@ import {
   withBrowserFonts,
 } from "../../scripts/lib/story-author/script.js";
 import { Site } from "../../scripts/lib/story-author/site.js";
+import { compile } from "../../scripts/lib/json-schema.mjs";
 import { fileFetch, nodeDecode } from "../../scripts/lib/headless.mjs";
+import { StoryData } from "../../src/story/data.js";
+import { Prefab } from "../../src/engine/prefab.js";
 import { loadStoryStore } from "../../src/story/assets.js";
 import { StoryPlayerCore } from "../../src/story/player-core.js";
 import "../../src/story/features/index.js";
@@ -39,13 +42,14 @@ const EPISODE = {
              { i: 2, cmd: "Stage", TargetAssetName: "other/hall" }],
   text: { t1: { english: "<b>Garden</b>" } },
 };
-const STORY = { advId: 9, episode: "episode.json", scene: "scene.json", ui: "ui/ui.json", models: { [MODELS.m_a]: "m_a" },
-                audio: { sound_bgm_adv_quiet_morning: "audio/sound_bgm_adv_quiet_morning", sound_se_adv_door: "audio/se" },
-                frames: "frames.json", chat: "chat.json", videos: "videos/videos.json" };
-const SCENE = { stages: { "st/garden": {}, "other/hall": {}, "st/hall": {} },
-                settings: { playerSettings: { _initializeEpisodes: [], _finalizeEpisodes: [] } } };
+const STORY = { format: 1, advId: 9, episode: "episode.json", parts: {
+  scene: "storyscenes/default.json", ui: { en: "storyui/en.json", ja: "storyui/ja.json" },
+  fonts: { en: "storyfonts/9_en.json", ja: "storyfonts/9_ja.json" },
+  models: { [MODELS.m_a]: "models/m_a.json" }, assets: { "Adv/Stage/st/garden": "storyassets/garden.json",
+    "Adv/Stage/other/hall": "storyassets/other_hall.json", "Adv/Stage/st/hall": "storyassets/hall.json" },
+  sounds: { sound_bgm_adv_quiet_morning: "cuesheets/sound_bgm_adv_quiet_morning.json", sound_se_adv_door: "cuesheets/se.json" } } };
 const BASE = { language: "en", languages: ["en", "ja"], story: STORY, episode: EPISODE,
-               stages: stageChoices(SCENE, EPISODE, "en"), music: musicChoices(EPISODE, STORY) };
+               stages: stageChoices(STORY.parts.assets, EPISODE, "en"), music: musicChoices(EPISODE, STORY) };
 const SITE = { base: BASE, models: MODELS, actions: ACTIONS };
 
 const script = (beats, extra = {}) => ({
@@ -80,9 +84,9 @@ test("the base story's stages with short ids and captions, its music and a stage
                                  { id: "st/hall", key: "st/hall", caption: "" }]);
   assert.deepEqual(BASE.music, [{ cue: "sound_bgm_adv_quiet_morning", label: "Quiet Morning", sound: 11,
                                   sheet: "sound_bgm_adv_quiet_morning" }]);
-  const prefab = { nodes: [{ components: [{ class: "Transform" }, { class: "AdvStage", _backgroundSprite: { texture: { texture: "textures/bg.png" } } }] }] };
-  assert.equal(stageBackground(prefab), "textures/bg.png");
-  assert.equal(stageBackground({ nodes: [] }), null);
+  const prefab = new Prefab({ nodes: [node("Stage", [mb("AdvStage", { _backgroundSprite: ref("test:1") })])] });
+  assert.equal(stageBackground(prefab, { sprite: () => ({ texture: { id: "test:2" } }) }), "test:2");
+  assert.equal(stageBackground(prefab, { sprite: () => null }), null);
 });
 
 test("a model's motions and expressions; the clip a motion plays at a position", () => {
@@ -189,10 +193,10 @@ test("a scene compiles to the game's rows: stage, music, entrances, focus, capti
   assert.equal(c.episode.master._titleTextId, "custom_title");
   assert.deepEqual(c.episode.sounds, { 11: EPISODE.sounds[11] });
   assert.deepEqual(c.episode.cuesheets, { 5: EPISODE.cuesheets[5] });
-  assert.deepEqual(c.story.audio, { sound_bgm_adv_quiet_morning: "audio/sound_bgm_adv_quiet_morning" });
-  assert.deepEqual(c.story.models, { [MODELS.m_a]: "m_a", [MODELS.m_b]: "m_b" });
-  assert.equal(c.story.ui, "ui/ui.json");
-  for (const k of ["frames", "chat", "videos"]) assert.equal(c.story[k], null);
+  assert.deepEqual(c.story.parts.sounds, { sound_bgm_adv_quiet_morning: "cuesheets/sound_bgm_adv_quiet_morning.json" });
+  assert.deepEqual(c.story.parts.models, { [MODELS.m_a]: "m_a", [MODELS.m_b]: "m_b" });
+  assert.deepEqual(c.story.parts.ui, STORY.parts.ui);
+  assert.deepEqual(c.story.parts.videos, {});
   assert.deepEqual(c.lines, [
     { line: 0, beat: 1, path: "/beats/1", id: "hi", speaker: "a", name: "Ann", text: "Hi <you>" },
     { line: 1, beat: 2, path: "/beats/2", speaker: null, name: "", text: "Wind." },
@@ -230,7 +234,7 @@ test("a second scene fades out, clears the stage and fades in; a positions beat
     { cmd: "Talk", AdvTextID: "custom_line_4", TargetName: "b", TargetTextIDs: ["custom_name_b"], TargetTextColors: ["#FFFFFF"] },
   ]);
   assert.equal(c.episode.title, null);
-  assert.equal(c.episode.master._titleTextId, 0);
+  assert.equal(c.episode.master._titleTextId, "");
   assert.deepEqual(c.episode.sounds, {});                  // music stopped while none plays: no row
   assert.equal(c.scenes, 2);
 });
@@ -355,7 +359,7 @@ test("the compiled rows are commands the story player runs", () => {
     { scene: "st/hall", music: "stop" },
     { narrate: "end" },
   ])).episode;
-  const settings = SCENE.settings.playerSettings;
+  const settings = { _initializeEpisodes: [], _finalizeEpisodes: [] };
   const missing = StoryPlayerCore.requiredCommands(ep, settings).filter((c) => !StoryPlayerCore.supportedCommands().includes(c));
   assert.deepEqual(missing, []);
   StoryPlayerCore.checkEpisode(ep, settings, "story script");
@@ -364,6 +368,7 @@ test("the compiled rows are commands the story player runs", () => {
 test("browser fonts: every font asset drawn in the family, with room for its underlay", () => {
   const fonts = {
     source: "open",
+    coverage: { characters: 1, missing: [], missingGlyph: ["x"] },
     fonts: {
       "F (G SDF)": { atlasPadding: 4, faceInfo: { m_PointSize: 40 }, characters: { 65: { glyph: 1 } }, glyphs: { 1: {} },
                      missingGlyph: { unicode: 9633, characters: [1] }, source: { generator: { margin: 8 } }, fallbacks: [] },
@@ -377,6 +382,7 @@ test("browser fonts: every font asset drawn in the family, with room for its und
   assert.deepEqual(out.fonts["F (G SDF)"].characters, {});
   assert.deepEqual(out.fonts["F (G SDF)"].glyphs, {});
   assert.equal(out.fonts["F (G SDF)"].missingGlyph, undefined);
+  assert.deepEqual(out.coverage, { characters: 0, missing: [] });
   assert.deepEqual(out.fonts["H (K SDF)"].fallbacks, ["F (G SDF)"]);
   assert.deepEqual(fonts.fonts["F (G SDF)"].characters, { 65: { glyph: 1 } });          // the input is kept
   assert.match(fontFamily({ preset: "sans" }, "zh-Hans"), /Noto Sans SC/);
@@ -386,7 +392,7 @@ test("browser fonts: every font asset drawn in the family, with room for its und
 
 // ------------------------------------------------------------------------------------------------ a synthetic site
 
-const FONTS = { format: 1, source: "open", language: "en", fonts: { "F SDF": { atlasPadding: 4, faceInfo: { m_PointSize: 40 },
+const FONTS = { format: "nnnotes.story-fonts/1", source: "open", language: "en", fonts: { "F SDF": { atlasPadding: 4, faceInfo: { m_PointSize: 40 },
   characters: { 65: { glyph: 1 } }, glyphs: { 1: {} }, fallbacks: [] } }, materials: {}, textures: {} };
 
 // a site with the base story stories/9.json (format /2, languages en and ja) and the models m_a and m_b
@@ -400,24 +406,27 @@ const makeSite = () => {
     models.push({ id, group: "g", key: man.subject, manifest: `models/${id}.json` });
   }
   fs.writeFileSync(path.join(dir, "models.json"), JSON.stringify({ format: 2, models }));
-  const scene = { ...SCENE, stages: { "st/garden": { nodes: [{ components: [{ class: "AdvStage",
-    _backgroundSprite: { texture: { texture: "textures/bg.png" } } }] }] }, "st/hall": {} } };
-  const story = { ...STORY, models: { "Character/Live2D/g/m_a/model/m_a": "m_a" } };
-  const files = putFiles(dir, {
-    "story.json": story, "episode.json": EPISODE, "scene.json": scene, "ui/ui.json": { nodes: [] },
-    "frames.json": {}, "chat.json": {}, "textures/bg.png": png(8, 4), "textures/unused.png": png(2, 2),
-    "audio/sound_bgm_adv_quiet_morning/cues.json": { cues: [] }, "audio/se/cues.json": { cues: [1] },
-  });
-  const lang = (l) => ({ files: putFiles(dir, { "ui/fonts.json": { ...FONTS, language: l }, "ui/languages.json": { language: l } }) });
-  const manifest = {
-    format: "ournotes.story-manifest/2", advId: 9, root: "../", language: "en", audio: true, audioFormat: "flac", fonts: "open",
-    story: { advId: 9, asset: "s", playbackMode: 0, titles: { en: "Base" }, groups: [], commands: [], commandCount: 0,
-             language: "en", languages: ["en", "ja"] },
-    requires: { commands: [], cubismCore: true, motionSync: false }, files, models: { m_a: "models/m_a.json" },
-    languages: { en: lang("en"), ja: lang("ja") },
+  const product = (file, kind, subject, own, objects = {}, extra = {}) => {
+    const manifest = { schema: "nnnotes.product/1", product: kind, subject, files: putFiles(dir, own), objects, ...extra };
+    fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true });
+    fs.writeFileSync(path.join(dir, file), JSON.stringify(manifest));
   };
-  fs.mkdirSync(path.join(dir, "stories"), { recursive: true });
-  fs.writeFileSync(path.join(dir, "stories", "9.json"), JSON.stringify(manifest));
+  const story = structuredClone(STORY);
+  delete story.parts.assets["Adv/Stage/other/hall"];
+  story.parts.models = { "Character/Live2D/g/m_a/model/m_a": "models/m_a.json" };
+  const o = new ModelObjects("stage"), texture = o.texture("background", { image: png(8, 4), width: 8, height: 4 });
+  const sprite = o.add("Sprite", "background", { json: JSON.stringify({ sprite: { m_Name: "background" },
+    renderData: { texture: ref(texture), uvTransform: { x: 1, y: 0, z: 1, w: 0 } } }) });
+  const prefab = o.prefab([node("Stage", [mb("AdvStage", { _backgroundSprite: ref(sprite) })])]);
+  const objects = Object.fromEntries(Object.entries(o.objects).map(([id, object]) => [id, { ...object, files: putFiles(dir, object.files) }]));
+  for (const [key, file] of Object.entries(story.parts.assets)) product(file, "story.asset", key, { "asset.json": { format: 1, objects: [prefab] } }, objects);
+  product(story.parts.scene, "story.scene", "default", { "scene.json": { format: 1, settings: {} } });
+  for (const lang of ["en", "ja"]) {
+    product(story.parts.ui[lang], "story.ui", lang, { "ui.json": { format: 1, language: { code: lang } } });
+    product(story.parts.fonts[lang], "story.fonts", `9/${lang}`, { "fonts.json": { ...FONTS, language: lang } });
+  }
+  for (const [sheet, file] of Object.entries(story.parts.sounds)) product(file, "story.sound", sheet, { "cues.json": {} });
+  product("stories/9.json", "story", "9", { "story.json": story, "episode.json": { ...EPISODE, advId: 9 } }, {}, { language: "en" });
   fs.writeFileSync(path.join(dir, "stories.json"), JSON.stringify({ format: "ournotes.stories/1", stories: [
     { id: "9", manifest: "stories/9.json", advId: 9, asset: "s", playbackMode: 0, titles: { en: "Base" }, groups: [],
       language: "en", languages: ["en", "ja"] },
@@ -439,13 +448,14 @@ test("a site: base stories, the stories a script can use, models and their actio
     const b = await site.base("stories/9.json", "ja");
     assert.equal(b.language, "ja");
     assert.deepEqual(b.languages, ["en", "ja"]);
-    assert.deepEqual(b.stages.map((s) => [s.id, s.background]), [["garden", "textures/bg.png"], ["hall", null]]);
+    assert.deepEqual(b.stages.map((s) => [s.id, s.background]), [["garden", "stage:1"], ["hall", "stage:1"]]);
+    assert.deepEqual((await site.baseFiles(b, ["stage:1"])).get("stage:1"), png(8, 4));
     assert.deepEqual(b.cast, ["m_a"]);
     assert.equal(b.fonts.language, "ja");
     assert.deepEqual((await site.model("m_b")).actions,
                      { motions: ["mtn_idle"], expressions: ["exp_idle"], defaultMotion: "mtn_idle", defaultExpression: "exp_idle" });
     await assert.rejects(site.model("m_x"), /not in models.json/);
-    await assert.rejects(site.base("stories/9.json", "ko"), /no language ko/);
+    await assert.rejects(site.base("stories/9.json", "ko"), /no ui for language ko/);
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 });
 
@@ -481,16 +491,27 @@ test("the commands without a browser: new, check, build; the built story loads",
     assert.equal(r.out.manifest, "custom-stories/mine.json");
     const url = pathToFileURL(path.join(dir, "custom-stories", "mine.json")).href;
     const man = JSON.parse(fs.readFileSync(new URL(url), "utf8"));
-    assert.deepEqual(Object.keys(man.languages), ["en"]);
-    assert.deepEqual(man.models, { m_a: "models/m_a.json", m_b: "models/m_b.json" });
-    assert.ok(!man.files["frames.json"] && !man.files["chat.json"] && !man.files["textures/unused.png"] && !man.files["audio/se/cues.json"]);
-    assert.ok(man.files["textures/bg.png"] && man.files["audio/sound_bgm_adv_quiet_morning/cues.json"]);
-    assert.equal(man.audio, true);
-    const store = await loadStoryStore(url, { fetch: fileFetch, decode: nodeDecode });
-    assert.equal(store.json("episode.json").commands.filter((c) => c.cmd === "Talk").length, 2);
-    assert.deepEqual(store.json("story.json").models, { "Character/Live2D/g/m_a/model/m_a": "m_a", "Character/Live2D/g/m_b/model/m_b": "m_b" });
-    assert.deepEqual(store.json("ui/fonts.json").fonts["F SDF"].browser.family.split(",")[0], "\"Noto Sans\"");
-    assert.ok(store.has("live2d/m_b/model.json"));
+    assert.equal(man.schema, "nnnotes.product/1");
+    assert.equal(man.product, "story");
+    assert.equal(man.language, "en");
+    assert.deepEqual(Object.keys(man.files), ["episode.json", "story.json"]);
+    const store = await loadStoryStore(url, { fetch: fileFetch, decode: nodeDecode }), data = new StoryData(store);
+    const episodeSchema = compile(JSON.parse(fs.readFileSync(new URL("../../schema/episode.schema.json", import.meta.url), "utf8")));
+    assert.deepEqual(episodeSchema(data.episode), []);
+    assert.equal(data.episode.commands.filter((c) => c.cmd === "Talk").length, 2);
+    assert.deepEqual(data.story.parts.models, { "Character/Live2D/g/m_a/model/m_a": "models/m_a.json", "Character/Live2D/g/m_b/model/m_b": "models/m_b.json" });
+    assert.deepEqual(Object.keys(data.story.parts.sounds), ["sound_bgm_adv_quiet_morning"]);
+    assert.deepEqual(data.fonts.fonts["F SDF"].browser.family.split(",")[0], "\"Noto Sans\"");
+    assert.ok(store.has("models/m_b/model.json"));
+
+    fs.writeFileSync(file, JSON.stringify({ ...doc, language: "ja", title: "" }));
+    r = run(["build", file, "--site", dir, "--name", "japanese"]);
+    assert.equal(r.status, 0, r.err);
+    const japanese = new StoryData(await loadStoryStore(pathToFileURL(path.join(dir, r.out.manifest)).href,
+      { fetch: fileFetch, decode: nodeDecode }));
+    assert.equal(japanese.ui.language.code, "ja");
+    assert.equal(japanese.fonts.language, "ja");
+    assert.deepEqual(episodeSchema(japanese.episode), []);
 
     fs.writeFileSync(file, JSON.stringify({ ...doc, beats: [{ say: "b", text: "x" }] }));
     r = run(["check", file, "--site", dir]);
diff --git a/tests/unit/story-chat-resources.mjs b/tests/unit/story-chat-resources.mjs
new file mode 100644
index 0000000..f5c1eec
--- /dev/null
+++ b/tests/unit/story-chat-resources.mjs
@@ -0,0 +1,39 @@
+import { Prefab } from "../../src/engine/prefab.js";
+import { nativeComponent } from "./story-screen-resources.mjs";
+
+export const chatWidgetPrefab = (widget) => {
+  const first = widget.nodes[0], parent = first.path.slice(0, first.path.lastIndexOf("/"));
+  const roots = parent ? [{ ...first, path: parent, name: parent.split("/").at(-1), components: [], rect: undefined }] : [];
+  return new Prefab({ key: "chat-widget", nodes: [...roots, ...widget.nodes.map((n) => {
+  const components = [];
+  const add = (cls, fields) => { if (fields) components.push(nativeComponent({ ...fields, class: cls })); };
+  add("Canvas", n.canvas); add("CanvasScaler", n.canvasScaler); add("CanvasGroup", n.canvasGroup);
+  if (n.chatView) add("AdvChatView", { ...n.chatView, _windowParentRect: { transform: n.chatView._windowParentRect } });
+  return { ...n, components };
+})] });
+};
+
+export const chatResources = (ctx, doc, widget = null) => {
+  const docs = Object.fromEntries(Object.entries(doc.windows).map(([name, p]) =>
+    [name, { ...p, nodes: p.nodes.map((n) => ({ ...n, components: n.components.map(nativeComponent) })) }]));
+  const prefabs = new Map(), sprites = new Map();
+  ctx.data = { story: { chats: doc.chats }, ui: { chatWidget: widget ? "fixture:widget" : null },
+    asset: (address) => {
+      const m = /^Adv\/Chat\/(Prefabs|Icon|Stamp)\/(.+)$/.exec(address);
+      const rec = m && (m[1] === "Prefabs" ? docs : m[1] === "Icon" ? doc.icons : doc.stamps)[m[2]];
+      if (!rec) throw new Error(`${address}: not in the chat data`);
+      return { objects: [m[1] === "Prefabs" ? m[2] : rec] };
+    } };
+  ctx.assets = { prefab: (id) => docs[id] };
+  ctx.objects = {
+    prefab: (id) => {
+      if (!prefabs.has(id)) prefabs.set(id, id === "fixture:widget" ? chatWidgetPrefab(widget) : new Prefab(docs[id]));
+      return prefabs.get(id);
+    },
+    sprite: (s) => {
+      if (!s) return null;
+      if (!sprites.has(s)) sprites.set(s, { ...s, id: s.sprite, texture: { ...s.texture, id: s.texture.texture } });
+      return sprites.get(s);
+    },
+  };
+};
diff --git a/tests/unit/story-core.test.mjs b/tests/unit/story-core.test.mjs
index b18604a..0d89c6a 100644
--- a/tests/unit/story-core.test.mjs
+++ b/tests/unit/story-core.test.mjs
@@ -66,7 +66,7 @@ const makeStory = (commands, { auto = true, speed = 10, shortCutIndex = -1 } = {
   const ui = checkStoryUI(new TimingUI(loop, log));
   const episode = { advId: 1, commands, text: TEXT, sounds: SOUNDS, cuesheets: { 1: { _cueSheetName: "s" } } };
   const assets = { json: () => CUES };
-  const resolve = (id) => { const s = SOUNDS[id]; return { sheet: "s", cue: s._cueName, category: s._category, row: s }; };
+  const resolve = (id) => { const s = SOUNDS[id]; return { sheet: "s", cue: s._cueName, category: s._category, row: s, meta: CUES[s._cueName] }; };
   const audio = new SilentAudio(resolve, loop, { assets });
   loop.on("update", () => audio.update());
   const stub = { stopAlwaysUpdate() {}, markUpdateOnce() {} };
@@ -575,26 +575,29 @@ test("AdvGlobalVolume.applyStageAllVolume: the stage's profile by index, else di
 });
 
 test("Overlay episodes go to the simple player (manifest and session)", async () => {
-  const { STORY_MANIFEST_FORMAT, fetchStoryManifest } = await import("../../src/story/assets.js");
+  const { fetchStoryManifest } = await import("../../src/story/assets.js");
   const { StorySession } = await import("../../src/story/session.js");
   const { SimpleStorySession } = await import("../../src/story/simple/session.js");
-  const man = { format: STORY_MANIFEST_FORMAT, advId: 5, story: { playbackMode: 1 },
-                requires: { commands: ["In", "LookTarget", "Stage", "Talk"] } };
-  const fetch = async () => ({ ok: true, json: async () => man });
-  assert.equal((await fetchStoryManifest("https://example.org/stories/5.json", { fetch })).manifest.advId, 5);
-  man.requires.commands.push("Effect");                       // the one row of the simple set not reproduced
-  await assert.rejects(fetchStoryManifest("https://example.org/stories/5.json", { fetch }),
-                       (e) => e instanceof StoryCommandError && /story 5: .*Effect/.test(e.message));
+  const { storyFixture, STORY_ROOT } = await import("./story-product-fixture.mjs");
+  const fixture = storyFixture({ overlay: true });
+  assert.equal((await fetchStoryManifest(`${STORY_ROOT}stories/7.json`, { fetch: fixture.fetch })).story.advId, 7);
+  const effect = storyFixture({ overlay: true, command: "Effect" });
+  await assert.rejects(fetchStoryManifest(`${STORY_ROOT}stories/7.json`, { fetch: effect.fetch }),
+    (e) => e instanceof StoryCommandError && /story 7: .*Effect/.test(e.message));
   const files = {
     "story.json": { episode: "episode.json", scene: "scene.json", ui: "ui/ui.json" },
     "episode.json": { advId: 5, master: { _playbackMode: 1 }, commands: [{ i: 0, cmd: "Stage" }, { i: 1, cmd: "Talk", AdvTextID: "1" }], text: {} },
     "scene.json": { settings: { playerSettings: {} } },
   };
-  const store = { info: {}, has: (n) => n in files, json: (n) => files[n] };
+  files["story.json"].parts = { scene: "scenes/default.json" };
+  files["scene.json"].format = 1;
+  files["scene.json"].settings.playerSettings = "settings:1";
+  const store = { info: { product: "story", dir: "stories/5", products: {} }, mono: () => ({}),
+    has: (n) => n in files, json: (n) => files[n.split("/").at(-1)] };
   assert.equal(SimpleStorySession.isSimpleStory(store), true);
   assert.deepEqual(StorySession.requirements(store),
                    { commands: ["Talk"], skipped: ["Stage"], unsupported: [], invalid: null });
   // the simple session loads: without its talk window data it refuses the story
   await assert.rejects(StorySession.create(null, store),
-                       (e) => e instanceof StoryCommandError && /story 5: the simple talk window/.test(e.message));
+                       (e) => e instanceof StoryCommandError && /story 5: the simple UI product/.test(e.message));
 });
diff --git a/tests/unit/story-feature-canvas.test.mjs b/tests/unit/story-feature-canvas.test.mjs
index 2253238..389855d 100644
--- a/tests/unit/story-feature-canvas.test.mjs
+++ b/tests/unit/story-feature-canvas.test.mjs
@@ -1,3 +1,4 @@
+import { nativeComponent } from "./story-screen-resources.mjs";
 // Canvas prefab geometry off the canvas plane: rotations about x / y and z offsets placed by the node's 3D matrix
 // (perspective canvases keep z for the camera's projection, orthographic ones drop it), and Quaternion.eulerAngles.
 // Synthetic inputs only.
@@ -16,10 +17,10 @@ const image = { type: "MonoBehaviour", class: "Image", m_Enabled: 1, m_Material:
                 m_Sprite: null, m_Type: 0, m_PreserveAspect: 0, m_FillCenter: 1, m_UseSpriteMesh: 0, m_PixelsPerUnitMultiplier: 1 };
 const node = (path, rect, components = [], extra = {}) => ({ path, name: path.split("/").pop(), active: true,
   localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 },
-  rect, components, ...extra });
+  rect, components: components.map(nativeComponent), ...extra });
 
 const build = (perspective, rot, z = 0) => {
-  const c = new ScreenCanvas("C", { sortingOrder: 1, scaler: SCALER });
+  const c = new ScreenCanvas("C", { sortingOrder: 1, scaler: SCALER }, { sprite: () => null });
   if (perspective) c.perspective = { fov: 60 };
   new CanvasPrefab([node("p", FULL, [], { localRotation: rot }),
                     node("p/img", CENTRE(100, 40), [{ type: "CanvasRenderer" }, image], { localPosition: { x: 0, y: 0, z } })], c.root, c);
@@ -74,6 +75,8 @@ test("Image Tiled: a trimmed sprite tiles at its full rect size with the uvs of
                 localScale: { x: 1, y: 1, z: 1 }, components: [img],
                 rect: { m_AnchorMin: { x: 0.5, y: 0.5 }, m_AnchorMax: { x: 0.5, y: 0.5 }, m_AnchoredPosition: { x: 0, y: 0 },
                         m_SizeDelta: { x: 25, y: 10 }, m_Pivot: { x: 0.5, y: 0.5 } } };
+  rec.components = rec.components.map(nativeComponent);
+  canvas.objects = { sprite: () => ({ ...sprite, id: "sprite:1", texture: { ...sprite.texture, id: "texture:1", wrapU: 1, wrapV: 1 } }) };
   const pf = new CanvasPrefab([rec], canvas.root, canvas);
   canvas.scaler = { m_UiScaleMode: 1, m_ReferenceResolution: { x: 100, y: 100 }, m_ScreenMatchMode: 0, m_MatchWidthOrHeight: 0,
                     m_ReferencePixelsPerUnit: 100 };
diff --git a/tests/unit/story-feature-chat.test.mjs b/tests/unit/story-feature-chat.test.mjs
index 1c85082..744447b 100644
--- a/tests/unit/story-feature-chat.test.mjs
+++ b/tests/unit/story-feature-chat.test.mjs
@@ -1,3 +1,4 @@
+import { chatResources } from "./story-chat-resources.mjs";
 // The chat rows on a real PlayerLoop at 30 fps with a synthetic chat window prefab and a stand-in story UI: opening,
 // closing and reconfiguring the phone, bubbles and read labels, the conversation memory and its restore, the typing
 // box, the waits, the incoming call fit, detaching while shortcutting. Synthetic inputs only.
@@ -100,7 +101,7 @@ const makePlayer = (rows, { auto = false, doc = chatDoc(), phone = false } = {})
   let indicator = false;
   const ui = { isTyping: false, showNextIndicator: () => { indicator = true; }, hideNextIndicator: () => { indicator = false; },
                get indicator() { return indicator; } };
-  if (phone) Object.assign(ui, { language: { mode: 1 }, fonts: { chatTexts: { [W]: {} } },
+  if (phone) Object.assign(ui, { language: { mode: 1 }, fonts: { texts: {} },
                                  doc: { chatWidget: chatWidget(), chatStatusTexts: { call_status: "Calling", lock_status: "Locked" } } });
   const texts = { 60001: "Read", 60004: "[stamp]", 11: "Group", 21: "hello there", 22: "me", 23: "typing!", 31: "Alice", s1_log: "[s1]" };
   const fieldRenderer = { foreground: { count: 0 }, addForegroundEntry() { this.foreground.count++; },
@@ -112,6 +113,7 @@ const makePlayer = (rows, { auto = false, doc = chatDoc(), phone = false } = {})
                             masterIds: { _chatReadTextId: "60001", _chatStampLogTextId: "60004" } },
                 episode: { commands: rows.map((r, i) => ({ i, ...r })), text: texts }, story: { chat: "chat/chat.json" },
                 assets: { json: (p) => { assert.equal(p, "chat/chat.json"); return doc; } } };
+  chatResources(ctx, doc, phone ? ui.doc.chatWidget : null);
   const p = { ctx, playbackSpeed: 10, cancelled: false, shortCutIndex: -1, isAutoPlay: auto, nextStep: 0, autoAdvCancel: null,
               session: { voicePlayIds: [], sePlayIds: [], withVoice: true },
               speedRate() { return this.playbackSpeed / 10; }, get shortcut() { return this.shortCutIndex >= 0; },
diff --git a/tests/unit/story-feature-clips.test.mjs b/tests/unit/story-feature-clips.test.mjs
deleted file mode 100644
index 4e76a57..0000000
--- a/tests/unit/story-feature-clips.test.mjs
+++ /dev/null
@@ -1,54 +0,0 @@
-// AnimRecords: controllers and clips written once per data file resolve across prefabs; animRecordProblems lists the
-// references that do not resolve (the data validator's check). Synthetic inputs only.
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { AnimRecords, animRecordProblems } from "../../src/story/features/clips.js";
-
-const FLT_MIN = -3.4028234663852886e+38;
-const clip = (name, to) => ({ clip: name, sampleRate: 60, wrapMode: 0, startTime: 0, stopTime: 1, loopTime: false, cycleOffset: 0,
-  events: [], bindings: [{ path: "", typeID: 225, class: "CanvasGroup", attribute: "m_Alpha" }],
-  streamed: { curveCount: 1, frames: [[FLT_MIN, [[0, 0, 0, 0, 0]]], [0, [[0, 0, 0, to, 0]]], [1, [[0, 0, 0, 0, to]]]] },
-  dense: { curveCount: 0 }, constant: [] });
-const ctrl = (name, clips) => ({ controller: name, name, parameters: [], defaultValues: [],
-  layers: [{ name: "Base Layer", stateMachine: 0 }],
-  clips, stateMachines: [{ defaultState: 0, anyStateTransitions: [], states: clips.map((c, i) => ({
-    name: `s${i}`, speed: 1, cycleOffset: 0, loop: false, writeDefaultValues: true, mirror: false, speedParam: "", timeParam: "",
-    blendTrees: [[{ clip: i, children: [] }]], transitions: [] })) }] });
-
-test("AnimRecords: a controller or clip reference resolves to the file's full record; ambiguous names raise", () => {
-  const doc = { frames: {
-    a: { nodes: [{ components: [{ type: "Animator", m_Controller: ctrl("c", [clip("in", 1), { clip: "in" }]) }] }] },
-    b: { nodes: [{ components: [{ type: "Animator", m_Controller: { controller: "c" } }] }] },
-    d: { nodes: [{ components: [{ type: "Animator", m_Controller: ctrl("d", [{ clip: "in" }]) }] }] },
-  } };
-  const r = new AnimRecords(doc);
-  const full = doc.frames.a.nodes[0].components[0].m_Controller;
-  assert.equal(r.controller({ controller: "c" }, "b"), full);
-  assert.equal(r.controller(null, "x"), null);
-  assert.throws(() => r.controller({ object: "AnimatorOverrideController" }, "x"), /not exported/);
-  assert.throws(() => r.controller({ controller: "nope" }, "x"), /controller nope not in the data/);
-  const c = r.controllerOf(full, "a");
-  assert.equal(c.states[0].clip, c.states[1].clip);                       // the repeated clip is one clip
-  const d = r.controllerOf(doc.frames.d.nodes[0].components[0].m_Controller, "d");
-  assert.equal(d.states[0].clip.length, 1);                               // a clip of another prefab's controller
-  const two = new AnimRecords({ x: [clip("in", 1), clip("in", 2)] });
-  assert.throws(() => two.controllerOf(ctrl("e", [{ clip: "in" }]), "e"), /two different clips named in/);
-});
-
-test("animRecordProblems: references without a full record, or with two different ones, in the file", () => {
-  const animator = (c) => ({ nodes: [{ components: [{ type: "Animator", m_Controller: c }] }] });
-  // a letterbox-like file: the second frame names the first one's controller; a later controller reuses its clip
-  const ok = { frames: { black: animator(ctrl("lb", [clip("in", 1), { clip: "in" }])), white: animator({ controller: "lb" }),
-                         other: animator(ctrl("o", [{ clip: "in" }])), none: animator(null) } };
-  assert.deepEqual(animRecordProblems(ok), []);
-  // the controller only as a reference (its full record left out of the file), a clip reference without its clip
-  assert.deepEqual(animRecordProblems({ frames: { white: animator({ controller: "lb" }), o: animator(ctrl("o", [{ clip: "gone" }])) } }),
-                   ["controller lb: referenced, not in the file", "clip gone: referenced, not in the file"]);
-  // two different full clips under one name: a reference through the file is ambiguous; a controller's own full clip
-  // resolves its own reference first
-  const two = { a: animator(ctrl("a", [clip("in", 1), { clip: "in" }])), b: animator(ctrl("b", [clip("in", 2)])),
-                c: animator(ctrl("c", [{ clip: "in" }])) };
-  assert.deepEqual(animRecordProblems(two), ["clip in: referenced, two different full records in the file"]);
-  assert.deepEqual(animRecordProblems({ a: animator(ctrl("a", [clip("in", 1), clip("in", 2)])) }),
-                   ["controller a: two different clips named in"]);
-});
diff --git a/tests/unit/story-feature-effect.test.mjs b/tests/unit/story-feature-effect.test.mjs
index 1ca7ef7..6497644 100644
--- a/tests/unit/story-feature-effect.test.mjs
+++ b/tests/unit/story-feature-effect.test.mjs
@@ -9,7 +9,7 @@ import { UnityRandom } from "../../src/engine/random.js";
 import { commandHandler, createStoryUILayers } from "../../src/story/interfaces.js";
 import { disposeStoryFeatures, installStoryFeatures, setStoryFeaturesSpeed } from "../../src/story/features/index.js";
 import { AdvParticleEffect, characterSortBand, createStageParticleGroups, releaseStageParticleGroups, storyEffects } from "../../src/story/features/effect.js";
-import { AnimRecords } from "../../src/story/features/clips.js";
+import { AnimClip, AnimController } from "../../src/engine/anim.js";
 import { Prefab } from "../../src/engine/prefab.js";
 
 const flush = () => new Promise((res) => setImmediate(res));
@@ -39,7 +39,8 @@ const psr = (order) => ({ type: "ParticleSystemRenderer", m_Enabled: 1, m_Render
   m_SortingLayer: 0, m_SortingLayerID: 0, m_SortingOrder: order, m_NormalDirection: 1, m_MaskInteraction: 0,
   m_UseCustomVertexStreams: 0, m_Materials: [{ material: "m", shader: { shader: "Mobile/Particles/Additive" } }] });
 const node = (path, components, active = true) => ({ path, name: path.split("/").pop(), active, layer: 0, tag: 0,
-  localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 }, components });
+  localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 }, components: components.map(({ type, class: cls, ...fields }, i) =>
+    ({ type, ...(cls ? { script: `Test||${cls}` } : {}), pathId: String(i), fields })) });
 
 const FLT_MIN = -3.4028234663852886e+38;
 const animator = { type: "Animator", m_Enabled: 1, m_UpdateMode: 0, m_CullingMode: 0, m_ApplyRootMotion: false,
@@ -56,6 +57,17 @@ const animator = { type: "Animator", m_Enabled: 1, m_UpdateMode: 0, m_CullingMod
       { name: "stop", speed: 1, cycleOffset: 0, loop: false, writeDefaultValues: true, mirror: false, speedParam: "", timeParam: "",
         blendTrees: [[{ clip: 1, children: [] }]], transitions: [] }] }] } };
 
+const effectObjects = {
+  material: (m) => ({ ...m, id: m.material, shader: m.shader.shader }),
+  mesh: (m) => m,
+  controller: (raw) => {
+    if (!raw) return null;
+    const clips = new Map(raw.clips.filter((c) => c.bindings).map((c) => [c.clip, c]));
+    return AnimController.fromMecanim(raw, (c) => AnimClip.fromMecanim(clips.get(c.clip), c.clip));
+  },
+};
+const effectPrefab = (doc) => { const p = new Prefab(doc); p.ids = ["fixture:effect"]; return p; };
+
 const effectDoc = () => ({ effects: { "fx/a": { key: "Adv/Effect/fx/a", nodes: [
   node("a", [psr(0), ps({ rate: 20, lifetime: 0.5 }), { type: "MonoBehaviour", class: "AdvParticleEffect", _particleSystem: { component: "ParticleSystem", gameObject: "a" } }]),
   node("a/Root", [animator]),
@@ -70,10 +82,10 @@ const makePlayer = () => {
   const fr = { entries, entryOf: (pos) => entries[{ 1: 0, 3: 1, 5: 2, 7: 3, 9: 4 }[pos]] || null, listeners: [],
                onCharacterOrderChanged(fn) { this.listeners.push(fn); return () => {}; } };
   const cam = new Transform("MainCamera"); cam.localPosition = { x: 0, y: 1, z: -10 };
-  const ctx = { loop, ui: { layers: createStoryUILayers(), trueCanvasSortOrder: 300 }, gl: null, renderer: null,
+  const ctx = { objects: effectObjects, data: { asset: () => ({ objects: ["fixture:effect"] }) }, loop, ui: { layers: createStoryUILayers(), trueCanvasSortOrder: 300 }, gl: null, renderer: null,
                 camera: { transform: cam }, field: { stageTransform: (pt) => stageT[{ 1: 0, 3: 1, 5: 2, 7: 3, 9: 4 }[pt]] },
                 fieldRenderer: fr, episode: { commands: [{ i: 0, cmd: "Effect", TargetName: "star", TargetAssetName: "fx/a" }] },
-                story: { effects: "effects.json" }, assets: { json: () => effectDoc() } };
+                story: { effects: "effects.json" }, assets: { prefab: () => effectDoc().effects["fx/a"] } };
   const p = { ctx, playbackSpeed: 10, shortCutIndex: -1, session: { stage: { backgroundFieldPosition: { x: 0, y: 0, z: 20 } } },
               speedRate() { return this.playbackSpeed / 10; }, get shortcut() { return false; } };
   return { ctx, p, loop, fr, stageT };
@@ -149,7 +161,7 @@ test("stage particle groups: effects over the stage prefab, shared between group
   ] });
   const ref = (p) => ({ component: "MonoBehaviour", class: "AdvParticleEffect", gameObject: p });
   const coll = { _groups: [{ _particleEffects: [ref("st/Rain")] }, { _particleEffects: [ref("st/Rain"), ref("st/Off/Snow")] }] };
-  const groups = createStageParticleGroups(t.ctx, "st", stage, coll, new AnimRecords({}));
+  const groups = createStageParticleGroups(t.ctx, "st", stage, coll, effectObjects);
   const [rain, snow] = groups[1];
   assert.equal(groups[0][0], rain);
   assert.equal(rain.isVisible, false);
@@ -170,7 +182,7 @@ test("stage particle groups: effects over the stage prefab, shared between group
   const nested = { _groups: [{ _particleEffects: [ref("st/Off"), ref("st/Off/Snow")] }] };
   const stage2 = new Prefab({ key: "st", nodes: [node("st", []), node("st/Off", [ps({}), psr(0), comp("st/Off")]),
                                                  node("st/Off/Snow", [ps({}), psr(0), comp("st/Off/Snow")])] });
-  assert.throws(() => createStageParticleGroups(t.ctx, "st", stage2, nested, new AnimRecords({})), /nested/);
+  assert.throws(() => createStageParticleGroups(t.ctx, "st", stage2, nested, effectObjects), /nested/);
   disposeStoryFeatures(t.ctx);
 });
 
@@ -183,7 +195,7 @@ test("AdvParticleEffect: a MeshRenderer with its MeshFilter is a renderer of the
   const bg = node("a/Root/Bg", [{ type: "MeshFilter", m_Mesh: quad }, mr]);
   bg.localPosition = { x: 0, y: 0, z: 0.2 }; bg.localScale = { x: 20, y: 15, z: 1 };
   const doc = effectDoc().effects["fx/a"];
-  const e = new AdvParticleEffect("spot", { ...doc, nodes: [...doc.nodes, bg] }, { rng: new UnityRandom(1) });
+  const e = new AdvParticleEffect("spot", effectPrefab({ ...doc, nodes: [...doc.nodes, bg] }), { rng: new UnityRandom(1), objects: effectObjects });
   assert.deepEqual(e.renderers.map((r) => r.kind), ["particle", "particle", "particle", "mesh"]);
   assert.deepEqual(e.relativeSortOrders, [-1, 1, -2, -1]);                // the mesh's 0 ranks with the particles' 0
   e.setSortOrder(305);                                                    // SetSortOrder: particle renderers only
@@ -195,7 +207,7 @@ test("AdvParticleEffect: a MeshRenderer with its MeshFilter is a renderer of the
   assert.ok(Math.abs(it.distance - 10.2) < 1e-5, `${it.distance}`);      // the quad's centre at z 0.2
   const part = e.renderers[3].target.parts[0];
   assert.deepEqual([part.stride, Object.keys(part.attribs)], [8, ["in_POSITION0", "in_NORMAL0", "in_TEXCOORD0"]]);
-  assert.throws(() => new AdvParticleEffect("bad", { ...doc, nodes: [...doc.nodes, node("a/Root/M", [mr])] }), /MeshRenderer without a MeshFilter/);
+  assert.throws(() => new AdvParticleEffect("bad", effectPrefab({ ...doc, nodes: [...doc.nodes, node("a/Root/M", [mr])] })), /MeshRenderer without a MeshFilter/);
 });
 
 test("AdvParticleEffect: a field item's draw hands the field renderer's per-object hook a Transform and the layer", () => {
@@ -208,8 +220,8 @@ test("AdvParticleEffect: a field item's draw hands the field renderer's per-obje
   bg.localPosition = { x: 0, y: 0, z: 0.2 }; bg.localScale = { x: 20, y: 15, z: 1 };
   const doc = effectDoc().effects["fx/a"];
   // FxMaterial.draw calls ctx.perObject(matrix of the draw)
-  const materials = { get: () => ({ queue: 3000, draw: (ctx, mesh, M) => ctx.perObject(M) }) };
-  const e = new AdvParticleEffect("spot", { ...doc, nodes: [...doc.nodes, bg] }, { rng: new UnityRandom(1), materials });
+  const materials = { mesh: (m) => m, record: (m) => m, get: () => ({ queue: 3000, draw: (ctx, mesh, M) => ctx.perObject(M) }) };
+  const e = new AdvParticleEffect("spot", effectPrefab({ ...doc, nodes: [...doc.nodes, bg] }), { rng: new UnityRandom(1), objects: effectObjects, materials });
   e.setLayerRecursively(8);
   const seen = [];
   const frame = { globals: {}, perObject: (t, layer) => { seen.push([Array.from(t.localToWorld()), layer]); return {}; } };
@@ -235,7 +247,7 @@ test("Effect: the command effects and the stage groups draw from a stream of the
   const comp = { type: "MonoBehaviour", class: "AdvParticleEffect", _particleSystem: { component: "ParticleSystem", gameObject: "st/Rain" } };
   const stage = new Prefab({ key: "st", nodes: [node("st", []), node("st/Rain", [ps({ rate: 30 }), psr(0), comp])] });
   const [[rain]] = createStageParticleGroups(t.ctx, "st", stage, { _groups: [{ _particleEffects: [{ ...comp, gameObject: "st/Rain" }] }] },
-                                              new AnimRecords({}));
+                                              effectObjects);
   rain.play();
   await steps(t.loop, 5);
   assert.ok(rain.particleSystem.particles.length > 0);
diff --git a/tests/unit/story-feature-frame.test.mjs b/tests/unit/story-feature-frame.test.mjs
index 992453f..ad52895 100644
--- a/tests/unit/story-feature-frame.test.mjs
+++ b/tests/unit/story-feature-frame.test.mjs
@@ -1,3 +1,4 @@
+import { screenResources } from "./story-screen-resources.mjs";
 // Frame (AdvFrameCommand) on a real PlayerLoop at 30 fps with synthetic frame prefabs: the toggle, Show / Hide
 // states, named states, the CanvasGroup fade, sibling order, the pre-delay, canvas size and the comment texts.
 // Synthetic inputs only.
@@ -122,6 +123,7 @@ const makePlayer = (rows, frames) => {
   const ctx = { loop, ui, episode: { commands: rows.map((r, i) => ({ i, ...r })) }, story: { frames: "frames.json", ui: "ui/ui.json" },
                 assets: { json: (p) => { assert.ok(docs[p], p); return docs[p]; } }, gl: null,
                 localize: (id) => `text ${id}` };
+  screenResources(ctx, docs["ui/ui.json"], frames);
   const p = {
     ctx, playbackSpeed: 10, cancelled: false, shortCutIndex: -1, delayOk: true,
     speedRate() { return this.playbackSpeed / 10; },
@@ -362,7 +364,14 @@ const textUI = ({ mode = 0, skip = [], problem = null } = {}) => {
 const ROW = { cmd: "Frame", TargetAssetName: SC, Parameter2: "p1", TargetTextIDs: ["1", "2", "3"] };
 const commentPlayer = (ui, frame = commentFrame()) => {
   const t = makePlayer([ROW], { [SC]: frame });
-  t.ctx.ui = { ...ui, layers: ui.layers };
+  const texts = {};
+  for (const n of t.ctx.assets.prefab(`fixture:${SC}`).nodes) {
+    const b = ui.fonts.frameTexts[SC][n.path];
+    if (!b) continue;
+    const c = n.components.find((c) => c.script?.endsWith("|TextMeshProUGUI"));
+    texts[`fixture:${c.pathId}`] = { font: b.localized };
+  }
+  t.ctx.ui = { ...ui, fonts: { texts }, layers: ui.layers };
   return t;
 };
 
@@ -402,24 +411,17 @@ test("Frame: the comment texts go through the UIText setter; the header lays out
   disposeStoryFeatures(t.ctx);
 });
 
-test("Frame: comment text bindings in English wrap; unbound texts refuse to draw; the load refuses texts the fonts cannot lay out", async () => {
+test("Frame: comment text bindings in English wrap; unbound texts fail at load; the load refuses texts the fonts cannot lay out", async () => {
   const en = commentPlayer(textUI({ mode: 1 }));
   await installStoryFeatures(en.ctx, en.p);
   assert.equal(frameView(en.ctx).loaded(SC).prefab.node(TEXT_PATHS.body).text.wrapping, 1);   // LocalizeText.OnFontChanged
   disposeStoryFeatures(en.ctx);
   const bare = commentPlayer(textUI({ skip: [TEXT_PATHS.body] }));
-  await installStoryFeatures(bare.ctx, bare.p);
-  const f = frameView(bare.ctx).loaded(SC);
-  assert.equal(f.prefab.node(TEXT_PATHS.body).text, undefined);
-  await settle(bare.loop, run(bare, ROW));
-  assert.equal(f.prefab.node(TEXT_PATHS.body).tmp.text, "text 3");
-  const screen = frameView(bare.ctx).screen;
-  screen.layoutAll(2340, 1080);
-  assert.throws(() => screen.canvas.frame.drawItems(), /canvas text without a text binding/);
+  await assert.rejects(installStoryFeatures(bare.ctx, bare.p), /no font binding/);
   disposeStoryFeatures(bare.ctx);
-  const drawing = commentPlayer(textUI({ skip: [TEXT_PATHS.body] }));      // a session that draws refuses it at load
+  const drawing = commentPlayer(textUI({ skip: [TEXT_PATHS.body] }));
   drawing.ctx.gl = {};
-  await assert.rejects(installStoryFeatures(drawing.ctx, drawing.p), /frame sc: texts without a text binding \(ui\/fonts.json frameTexts\): sc\/Root\/Camera\/Coments\/P1\/Card\/Body$/);
+  await assert.rejects(installStoryFeatures(drawing.ctx, drawing.p), /no font binding/);
   const bad = commentPlayer(textUI({ problem: "Test SDF: U+0021 not in the font data" }));
   await assert.rejects(installStoryFeatures(bad.ctx, bad.p), /frame sc: texts the story UI cannot lay out: Test SDF: U\+0021/);
 });
diff --git a/tests/unit/story-feature-scene.test.mjs b/tests/unit/story-feature-scene.test.mjs
index ed67ae6..ffccdfe 100644
--- a/tests/unit/story-feature-scene.test.mjs
+++ b/tests/unit/story-feature-scene.test.mjs
@@ -21,7 +21,9 @@ const makePlayer = ({ quality = {}, profiles = {} } = {}) => {
   const stage = { name: "st", changeLights(i) { calls.push(["lights", i]); }, changeParticleEffects(i) { calls.push(["effects", i]); } };
   const characters = new Map();
   const ui = { layers: createStoryUILayers(), flash(d) { calls.push(["flash", d]); return loop.delay(d); } };
-  const ctx = { loop, ui, volume, quality: { unityLighting: true, stageParticleEffect: true, stagePostEffect: true, ...quality },
+  const ctx = { data: { parts: { assets: Object.fromEntries(Object.keys(profiles).map((k) => [`Adv/PostEffect/${k}`, k])) },
+    asset: (address) => ({ objects: [address.slice("Adv/PostEffect/".length)] }) },
+    objects: { mono: (id) => ({ class: profiles[id].asset }), profile: (id) => profiles[id] }, loop, ui, volume, quality: { unityLighting: true, stageParticleEffect: true, stagePostEffect: true, ...quality },
                 field: { applyFocusStagePositions(st, i) { calls.push(["focus", st.name, i]); } },
                 fieldRenderer: { sortCharacters() { calls.push(["sort"]); } },
                 characters: { get: (n) => characters.get(n) }, episode: { commands: [] },
diff --git a/tests/unit/story-feature-still.test.mjs b/tests/unit/story-feature-still.test.mjs
index e95c4be..a4bf8db 100644
--- a/tests/unit/story-feature-still.test.mjs
+++ b/tests/unit/story-feature-still.test.mjs
@@ -1,3 +1,4 @@
+import { screenResources } from "./story-screen-resources.mjs";
 // Still (AdvStillCommand) and the DOTween model under it, on a real PlayerLoop at 30 fps with a synthetic still prefab
 // and story UI records: tween startup, delays, loops, deferred kills, Sequence inserts and callbacks, the filtered
 // Play / Kill; the still's show / hide fades, the view's overlay / background fades, sequences and their callbacks,
@@ -177,6 +178,7 @@ const makePlayer = () => {
                 field: { root: { localPosition: { ...Z } } }, background: { root: { localPosition: { ...Z } } },
                 episode: { commands: [{ i: 0, cmd: "Still", TargetAssetName: "st" }] },
                 story: { stills: "stills.json", ui: "ui/ui.json" }, assets: { json: (p) => { assert.ok(docs[p], p); return docs[p]; } } };
+  screenResources(ctx, docs["ui/ui.json"], docs["stills.json"].stills);
   const p = { ctx, playbackSpeed: 10, cancelled: false, shortCutIndex: -1,
               speedRate() { return this.playbackSpeed / 10; }, get shortcut() { return this.shortCutIndex >= 0; },
               calcDuration(d, def = 0) { return this.shortcut ? 0 : (d ? Math.max(d, 0) : def) / this.speedRate(); },
diff --git a/tests/unit/story-feature-uiparticle.test.mjs b/tests/unit/story-feature-uiparticle.test.mjs
index 09c895f..a315d16 100644
--- a/tests/unit/story-feature-uiparticle.test.mjs
+++ b/tests/unit/story-feature-uiparticle.test.mjs
@@ -1,3 +1,4 @@
+import { screenResources } from "./story-screen-resources.mjs";
 // Coffee UIParticle on the frame canvas (uiparticle.js) with synthetic frame prefabs, particle systems and UI camera:
 // the baked quad on the canvas for each auto scaling mode and simulation space, the driven scale, the generated
 // renderer nodes, activity, the checks at load and the headless path. Synthetic inputs only.
@@ -98,6 +99,7 @@ const setup = async (doc, { uiCamera = UI_CAMERA } = {}) => {
   const ctx = { loop, ui: { layers: createStoryUILayers() }, episode: { commands: [{ i: 0, cmd: "Frame", TargetAssetName: "f" }] },
                 story: { frames: "frames.json", ui: "ui/ui.json" }, gl: null, localize: (id) => `text ${id}`,
                 assets: { json: (p) => { assert.ok(docs[p], p); return docs[p]; } } };
+  screenResources(ctx, docs["ui/ui.json"], { f: doc });
   const p = { ctx, playbackSpeed: 10, cancelled: false, shortCutIndex: -1, speedRate() { return 1; }, get shortcut() { return false; },
               calcDuration(d, def = 0) { return d ? Math.max(d, 0) : def; }, delay: (sec) => loop.delay(sec),
               ease(s, def = EASE.OutQuad) { return def; }, noWait(c, task) { return task; } };
@@ -133,7 +135,7 @@ test("UIParticle: a Transform-scaled system is baked with the UI camera into a c
   const it = items[0];
   assert.equal(it.node.name, "[generated] UIParticleRenderer");
   assert.equal(fx.children[fx.children.length - 1], it.node);         // the last child of the UIParticle
-  assert.equal(it.material, MAT);
+  assert.equal(it.material, t.ctx.objects.material(MAT));
   assert.equal(it.texture, "textures/glow.png");
   assert.ok(t.canvas.materials.has("glow") && t.canvas.textures.has("textures/glow.png"));
   near(corners(it), fxQuad(t.canvas));
@@ -203,7 +205,7 @@ test("UIParticle: checks at load and at the first draw", async () => {
   const t = await setup(frame([uip(), ps(), psr()]), { uiCamera: null });
   await t.show();
   t.screen.layoutAll(2340, 1080);
-  assert.throws(() => t.screen.frameParticles.refresh(t.loop), /no UI camera \(uiCamera\)/);
+  assert.throws(() => t.screen.frameParticles.refresh(t.loop), /0 Camera/);
   disposeStoryFeatures(t.ctx);
 });
 
diff --git a/tests/unit/story-feature-video.test.mjs b/tests/unit/story-feature-video.test.mjs
index 893660b..19236e2 100644
--- a/tests/unit/story-feature-video.test.mjs
+++ b/tests/unit/story-feature-video.test.mjs
@@ -1,3 +1,4 @@
+import { screenResources } from "./story-screen-resources.mjs";
 // Movie / Clip / Subtitles on a real PlayerLoop at 30 fps with synthetic video records and a stand-in UI: the video
 // queue, the view's fades, the clip's frame clock and the timeline Delay rows follow, the clip's end, the stop marker,
 // the Movie's blocking, captions over a clip, the seek re-speed of an audio video on a speed change (the delay
@@ -85,13 +86,14 @@ const makePlayer = (rows, { auto = true } = {}) => {
     isShowingNextIndicator: () => indicator, isShowingTalk: () => false, showAutoButton: log("autoOn"), hideAutoButton: log("autoOff"),
     showFastForwardButton() {}, showVideoButtons: log("videoButtons"), hideVideoButtons() {}, resetPauseVideoButton() {} };
   const docs = { "ui/ui.json": uiDoc(), "videos/videos.json": { videos: { 11: video(11, 60), 12: video(12, 30), 13: video(13, 45, true) } } };
-  const ctx = { loop, ui, gl: null, camera: { setShakeOffset() {} }, field: { root: { localPosition: { ...Z } } },
+  const ctx = { data: { videoFor: (id) => docs["videos/videos.json"].videos[id] }, loop, ui, gl: null, camera: { setShakeOffset() {} }, field: { root: { localPosition: { ...Z } } },
                 background: { root: { localPosition: { ...Z } } },
                 settings: { player: { _waitVideoLingeringTimeOnAutoPlay: 0.3, _waitSubtitlesLingeringTimeOnAutoPlay: 0.1,
                                       _waitTalkTextUnitTime: 0.04, _minTalkDisplayTime: 1.6, _waitAfterVoiceTime: 0.6 } },
                 audio: { stop() {}, play: () => 0, isPlaying: () => false }, localize: (id) => `line ${id}`,
                 episode: { commands: rows.map((r, i) => ({ i, ...r })) }, story: { ui: "ui/ui.json", videos: "videos/videos.json" },
                 assets: { json: (p) => { assert.ok(docs[p], p); return docs[p]; } } };
+  screenResources(ctx, docs["ui/ui.json"], {});
   const p = { ctx, playbackSpeed: 10, cancelled: false, shortCutIndex: -1, isAutoPlay: auto, isPause: false, nextStep: 0, lineIndex: -1,
               session: { voicePlayIds: [], withVoice: true }, errors: [], fail(e) { this.errors.push(e); },
               speedRate() { return this.playbackSpeed / 10; }, get shortcut() { return this.shortCutIndex >= 0; },
diff --git a/tests/unit/story-home-resources.mjs b/tests/unit/story-home-resources.mjs
new file mode 100644
index 0000000..3a3e38b
--- /dev/null
+++ b/tests/unit/story-home-resources.mjs
@@ -0,0 +1,100 @@
+import { Prefab } from "../../src/engine/prefab.js";
+import { ShaderLib } from "../../src/engine/glsl.js";
+import { GLTex } from "../../src/engine/texture.js";
+
+// Synthetic component and product resources for camera, room and host rendering cases.
+export const volumeResources = (v) => ({ path: v.path, layer: v.layer, active: v.active,
+  fields: { m_Enabled: v.enabled, m_IsGlobal: v.isGlobal, weight: v.weight, priority: v.priority, blendDistance: v.blendDistance },
+  profile: v.profile ? { components: (v.components || []).map(({ class: asset, active, ...params }) => ({ asset, active,
+    ...Object.fromEntries(Object.entries(params).map(([k, m_Value]) => [k, { m_OverrideState: 1, m_Value }])) })) } : null });
+
+export const lightingResources = ({ graphics, quality, rendererIndex, renderSettings, lights, what }) => {
+  if (!graphics) throw new Error("URP lighting needs the scene's render settings");
+  const level = graphics.qualityLevels[quality];
+  if (!level) throw new Error(`quality level ${quality} is missing`);
+  const name = level.customRenderPipeline || graphics.defaultPipeline, pipeline = { ...graphics.pipelines[name], m_Name: name };
+  const renderer = pipeline.m_RendererDataList[rendererIndex < 0 ? pipeline.m_DefaultRendererIndex : rendererIndex];
+  return { pipeline, renderer: { ...graphics.renderers[renderer], m_Name: renderer }, renderSettings,
+    lightmaps: renderSettings?.lightmaps ? [{}] : [], lights, what };
+};
+
+export const homeResources = (store, spec, opts, gl = null) => {
+  const h = spec.home, prefabs = new Map(), records = new Map(), classes = new Map();
+  const node = (path, components = [], trs = {}) => ({ path, name: path.split("/").at(-1), active: true, layer: 0,
+    localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 }, ...trs, components });
+  const comp = (type, fields) => ({ type, fields });
+  const prefab = (id, nodes) => { classes.set(id, "GameObject"); const doc = { key: id, nodes }; records.set(id, doc); prefabs.set(id, new Prefab(doc)); };
+  const refs = (path) => ({ gameObject: path });
+  const volumes = [...(h.sceneRoot?.volumes || []), ...(h.volume ? [h.volume] : [])].map(volumeResources);
+  const scene = [node("Scene", [comp("SpotSceneRoot", { _objRoot: refs("Scene/Objects") })])];
+  const tr = h.sceneRoot?.objRoot;
+  scene.push(node("Scene/Objects", [], tr ? { localPosition: tr.position, localRotation: tr.rotation, localScale: tr.scale } : {}));
+  volumes.forEach((v, i) => {
+    records.set(`profile:${i}`, v.profile);
+    scene.push(node(`Scene/${v.path}`, [comp("Volume", { ...v.fields, sharedProfile: `profile:${i}` })], { active: v.active, layer: v.layer }));
+  });
+  for (const [i, l] of (h.sceneRoot?.lights || []).entries())
+    scene.push(node(`Scene/Light${i}`, [comp(l.type || "Light", l)], { active: l.active }));
+  prefab("scene", scene);
+  prefab("background", [node("Background", [], h.roomRoot)]);
+  prefab("camera", [node("Camera", [comp("CameraManager", { _mainCamera: refs("Camera") })])]);
+  const spot = store.json(h.spot), situation = [node("Situation")];
+  for (const [i, c] of spot.spineCharacters.entries()) {
+    if (!c.skeletonData) continue;
+    const extra = h.spineCharacters?.find((r) => r.path === c.path), path = `Situation/Character${i}`;
+    const skeleton = spot.skeletons.find((r) => r.name === c.skeletonData);
+    const pageNames = skeleton.atlases.flatMap((f) => (store.has(`host/spot/spine/${f}`) ? store.text(`host/spot/spine/${f}`) : "").split(/\r?\n/).filter((s) => s && !s.includes(":")));
+    const materials = pageNames.map((page) => extra?.pageMaterials?.[page] || (Object.keys(h.spineMaterials).length === 1
+      ? Object.keys(h.spineMaterials)[0] : `${page.replace(/\.[^.]*$/, "")}_Material`));
+    records.set(`skeleton:${i}`, { atlasAssets: [`atlas:${i}`] });
+    records.set(`atlas:${i}`, { atlasFile: `atlas-text:${i}`, materials });
+    records.set(`atlas-text:${i}`, new TextEncoder().encode(pageNames.map((n) => `${n}\nsize: 8,8\n`).join("\n")));
+    const components = [comp("SpotSpineCharacter", { _animation: refs(`${path}/Animation`) })];
+    situation.push(node(path, components));
+    situation.push(node(`${path}/Animation`, [comp("SkeletonAnimation", { skeletonDataAsset: `skeleton:${i}` }),
+      comp("MeshRenderer", { m_SortingOrder: extra?.sortingOrder ?? c.sortingOrder ?? 0 })]));
+    // The spot product identifies each character by the prefab path.
+    for (const n of situation.slice(-2)) n.path = n.path.replace(path, c.path);
+    components[0].fields._animation = refs(`${c.path}/Animation`);
+  }
+  // Synthetic character paths have a shared root named s.
+  if (situation.length > 1) { situation[0].path = "s"; situation[0].name = "s"; }
+  prefab("situation", situation);
+  classes.set("render-settings", "RenderSettings"); records.set("render-settings", h.sceneRoot?.renderSettings);
+  classes.set("lightmaps", "LightmapSettings"); records.set("lightmaps", { m_Lightmaps: h.sceneRoot?.renderSettings?.lightmaps ? [{}] : [] });
+  const graphics = opts.graphics;
+  records.set("quality", { m_QualitySettings: graphics?.qualityLevels || [] });
+  records.set("graphics", { m_CustomRenderPipeline: graphics?.defaultPipeline });
+  for (const [name, p] of Object.entries(graphics?.pipelines || {})) records.set(name, { ...p, m_Name: name });
+  for (const [name, r] of Object.entries(graphics?.renderers || {})) {
+    const features = r.m_RendererFeatures.map((f, i) => { const id = `feature:${name}:${i}`; records.set(id, f); return id; });
+    records.set(name, { ...r, m_Name: name, m_RendererFeatures: features, postProcessData: `post:${name}` });
+    const textures = opts.post?.textures?.[name];
+    records.set(`post:${name}`, { textures: textures ? { filmGrainTex: textures.filmGrainTex.map((t) => { records.set(t.name, t); return t.name; }) } : {} });
+  }
+  const material = (m, id) => ({ ...m, id, material: m.material || m.name, shader: m.shader?.shader || m.shader,
+    textures: Object.fromEntries(Object.entries(m.textures || m.texEnvs || {}).map(([k, v]) => [k, { ...v,
+      scale: Array.isArray(v.scale) ? { x: v.scale[0], y: v.scale[1] } : v.scale,
+      offset: Array.isArray(v.offset) ? { x: v.offset[0], y: v.offset[1] } : v.offset }])) });
+  const mats = new Map(h.roomMaterials.map((m, i) => [`material:${i}`, material(m, `material:${i}`)]));
+  for (const [id, m] of Object.entries(h.spineMaterials || {})) mats.set(id, material(m, id));
+  const index = new Map(store.json(h.shaders.index).map((r) => [r.name, r]));
+  store.object = (id) => ({ class: classes.get(id) });
+  store.hasObject = (id) => index.has(id) || records.has(id);
+  store.objectJson = (id) => records.get(id);
+  store.objectBytes = (id) => records.get(id);
+  store.prefab = (id) => records.get(id);
+  const objects = { assets: store, id: (v) => v || null, prefab: (id) => prefabs.get(id),
+    mono: (id) => records.get(id), profile: (id) => records.get(id), material: (id) => mats.get(id),
+    shaderNames: Object.fromEntries([...index.keys()].map((n) => [n, n])),
+    shaderInfo: (id) => store.json(`host/shaders/${index.get(id).parsed}`), uiBlur: () => h.blur,
+    texture: (id) => GLTex.load(gl, "", records.get(id), store), lib: gl ? new ShaderLib(gl, "host/shaders", store) : null };
+  const summary = { glb: "room.glb", nodes: h.roomNodes, materialIds: h.roomMaterials.map((_, i) => `material:${i}`) };
+  const data = { assets: store, scene: { prefabs: { cameraManager: "camera" }, graphics: { graphics: "graphics", quality: "quality" } },
+    story: { host: { talk: h.talk, characterId: h.characterId } },
+    host: { kind: "home", home: { spotId: h.spotId, background: "background", situation: "situation",
+      scene: ["scene", "render-settings", "lightmaps"], parts: { room: "room", spot: "spot" },
+      backgroundState: { nodes: Object.fromEntries(h.roomNodes.map((n) => [n.path, n])) } } },
+    document: (part) => part === "room" ? summary : store.json(h.spot), file: (_, file) => `host/spot/${file}` };
+  return { data, objects, summary };
+};
diff --git a/tests/unit/story-object-resources.test.mjs b/tests/unit/story-object-resources.test.mjs
new file mode 100644
index 0000000..5ea146e
--- /dev/null
+++ b/tests/unit/story-object-resources.test.mjs
@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AssetStore } from "../../src/data/assets.js";
+import { ObjectResources } from "../../src/engine/objects.js";
+import { AdvStageData } from "../../src/story/stage.js";
+import { uiTree, uiTextBinding } from "../../src/story/ui-objects.js";
+import { StoryPlayerCore } from "../../src/story/player-core.js";
+import { StoryData } from "../../src/story/data.js";
+import { ModelObjects, node, mb, component, ref } from "./live2d-objects.mjs";
+
+test("controllers resolve clips by object id even when clip names coincide", () => {
+  const o = new ModelObjects();
+  const clips = [0.2, 0.8].map((value) => o.clip({ name: "fade", bindings: [{ cls: "CanvasGroup", path: "", attribute: "m_Alpha" }], constant: [value] }));
+  const ctrl = o.add("AnimatorController", "controller", { json: JSON.stringify({ name: "controller", layers: [{ stateMachine: 0 }], clips: clips.map(ref), parameters: [],
+    stateMachines: [{ defaultState: 0, anyStateTransitions: [], states: clips.map((_, i) => ({ name: `state${i}`, speed: 1, writeDefaultValues: false,
+      transitions: [], blendTrees: [[{ clip: i, children: [] }]] })) }] }) });
+  const root = o.prefab([node("Root", [component("Animator", { m_Controller: ref(ctrl) })])]);
+  const objects = new ObjectResources(new AssetStore({ objects: o.objects }), { bindings: [{ [root]: { Root: o.bindings } }] });
+  const controller = objects.controller(ref(ctrl), root, "Root");
+  assert.deepEqual(controller.states.map((s) => s.clip.curves[0].constant), [Math.fround(0.2), Math.fround(0.8)]);
+  assert.equal(objects.controller(ctrl, root, "Root"), controller);
+  assert.notEqual(controller.states[0].clip, controller.states[1].clip);
+  assert.throws(() => objects.controller(root, root, "Root"), /not a AnimatorController/);
+  assert.throws(() => objects.clip(clips[0], root, "Absent"), /bindings/);
+});
+
+test("prefab references resolve game objects, transforms and script components", () => {
+  const o = new ModelObjects();
+  const root = o.prefab([node("Root", [mb("Control", {})], { pathId: "100", transformPathId: "101" }),
+    node("Root/Child", [{ ...component("Light", { m_Intensity: 2 }), pathId: "104" }], { pathId: "102", transformPathId: "103" })]);
+  const resources = new ObjectResources(new AssetStore({ objects: o.objects })), p = resources.prefab(root);
+  assert.equal(p.pathOf(ref("CAB-test:102")), "Root/Child");
+  assert.equal(p.transformOf(ref("CAB-test:103")), p.transform("Root/Child"));
+  assert.equal(p.componentOf(ref("CAB-test:104"), "Light").fields.m_Intensity, 2);
+  assert.throws(() => p.componentOf(ref("CAB-test:104"), "Camera"), /expected Camera/);
+  assert.throws(() => p.pathOf(ref("CAB-test:999")), /outside the hierarchy/);
+});
+
+test("stage profiles resolve by object identity even when their names coincide", () => {
+  const o = new ModelObjects();
+  const componentA = o.mono("Bloom", "Bloom", { intensity: { m_OverrideState: true, m_Value: 0.2 } });
+  const componentB = o.mono("Bloom", "Bloom", { intensity: { m_OverrideState: true, m_Value: 0.9 } });
+  const profiles = [componentA, componentB].map((c) => o.mono("VolumeProfile", "Profile", { components: [ref(c)] }));
+  const root = o.prefab([node("Stage", [mb("AdvStage", {
+    _backgroundSprite: null, _shadowTexture: null, _focusPointsCollection: { _entries: [] },
+    _particleEffectGroupCollection: { _groups: [] }, _lightGroupCollection: { _groups: [] },
+    _allVolumeProfileCollection: { _profiles: profiles.map(ref) },
+  })])]);
+  const resources = new ObjectResources(new AssetStore({ objects: o.objects }));
+  const stage = new AdvStageData(resources.prefab(root), resources);
+  assert.deepEqual(stage.volumeProfiles.map((p) => p.components[0].intensity.m_Value), [0.2, 0.9]);
+  assert.equal(stage.volumeProfile(0), resources.profile(profiles[0]));
+  assert.equal(stage.volumeProfile(0).components[0].asset, "Bloom");
+});
+
+test("parented UI instances keep font component identities and local reference targets", () => {
+  const o = new ModelObjects(), rect = { m_AnchorMin: { x: 0, y: 0 }, m_AnchorMax: { x: 1, y: 1 },
+    m_AnchoredPosition: { x: 0, y: 0 }, m_SizeDelta: { x: 0, y: 0 }, m_Pivot: { x: 0.5, y: 0.5 } };
+  const root = o.prefab([node("Window", [mb("Control", { target: { transform: "Window/Text" } })], { rect }),
+    node("Window/Text", [{ ...mb("TextMeshProUGUI", { m_fontSize: 30, m_Enabled: 1 }), pathId: "27" }], { rect })]);
+  const resources = new ObjectResources(new AssetStore({ objects: o.objects })), nodes = new Map();
+  const parent = { path: "Canvas/Talk", children: [] }, window = uiTree(resources, root, { parent, nodes });
+  const text = window.ref(window.fields("Control").target);
+  assert.equal(text.path, "Canvas/Talk/Window/Text");
+  const font = { fontAsset: "Face", material: "Default", lineSpacing: 3 };
+  const binding = uiTextBinding(text, { texts: { "CAB-test:27": { localized: { fontAsset: "Source Face" }, font } } });
+  assert.equal(binding.id, "CAB-test:27");
+  assert.equal(binding.m_fontSize, 30);
+  assert.equal(binding.localized, font);
+  assert.throws(() => uiTextBinding(text, { texts: {} }), /no font binding/);
+});
+
+test("camera focus settings are read through the referenced asset", () => {
+  const o = new ModelObjects();
+  const id = o.mono("AdvFocusDataSettings", "Focus", { _focusData: [{ _cameraDistance: 2, _fov: 30 }] });
+  const objects = new ObjectResources(new AssetStore({ objects: o.objects }));
+  const ctx = { objects, settings: { player: { _focusDataSettingsMap: { _list: [{ Key: "near", Value: ref(id) }] } } } };
+  assert.equal(StoryPlayerCore.prototype.focusDataSettings.call({ ctx }, "near")._focusData[0]._fov, 30);
+  assert.equal(StoryPlayerCore.prototype.focusDataSettings.call({ ctx }, "missing"), null);
+});
+
+test("CRI Lips and shared chat documents are resolved under their product directories", () => {
+  const parts = { crilips: "crilips/default.json", chat: "storychat/default.json" };
+  const weights = new Uint8Array(new Float32Array([0.25, 0.75]).buffer);
+  const assets = new AssetStore({ info: { product: "story", dir: "stories/1", products: {} }, text: {
+    "stories/1/story.json": JSON.stringify({ episode: "episode.json", parts }), "stories/1/episode.json": "{}",
+    "crilips/default/crilips.json": JSON.stringify({ dimensions: [2] }),
+    "storychat/default/chat.json": JSON.stringify({ format: 1, text: [], sounds: [], cueSheets: [] }),
+  }, bytes: { "crilips/default/crilips.bin": weights } });
+  const data = new StoryData(assets);
+  assert.deepEqual(data.crilips.descriptor.dimensions, [2]);
+  assert.deepEqual([...new Float32Array(data.crilips.data)], [0.25, 0.75]);
+  assert.deepEqual(data.chat.sounds, []);
+});
diff --git a/tests/unit/story-player.test.mjs b/tests/unit/story-player.test.mjs
index a8b41a6..93d28e4 100644
--- a/tests/unit/story-player.test.mjs
+++ b/tests/unit/story-player.test.mjs
@@ -19,7 +19,7 @@ const fakeSession = (lineCount = 10, line = -1) => ({
 // a StoryPlayer without its DOM: the members _startSession, play, pause and setLanguage read
 const bare = () => Object.assign(Object.create(StoryPlayer.prototype), {
   opts: {}, gl: null, store: {}, _lang: "ja", _auto: false, _speed: 10, _volumes: { Bgm: 1 }, _paused: false,
-  disposed: false, controls: null, session: null, _audioContext: null, _manifest: {}, _abort: new AbortController(),
+  disposed: false, controls: null, statusEl: {}, session: null, _audioContext: null, _manifest: {}, _abort: new AbortController(),
   _pixelSize: () => [130, 60], _emit() {}, _loadStore: async () => ({}), _exclusive: async (fn) => fn(),
 });
 
@@ -49,6 +49,7 @@ test("a seek before the first play, then a language: the new language starts at
     assert.deepEqual([opts[0].line, p._startLine, p.line, p.session.held], [5, 5, 4, [true]]);   // held while paused
     await p.setLanguage("en");
     assert.equal(opts[1].line, 5);
+    assert.equal(p.statusEl.hidden, true);
     p.session.line = 7;                                                  // played on: the current line
     await p.setLanguage("ko");
     assert.equal(opts[2].line, 7);
diff --git a/tests/unit/story-product-fixture.mjs b/tests/unit/story-product-fixture.mjs
new file mode 100644
index 0000000..03b3a03
--- /dev/null
+++ b/tests/unit/story-product-fixture.mjs
@@ -0,0 +1,46 @@
+export const STORY_ROOT = "https://example.test/out/";
+const encoder = new TextEncoder();
+
+export const storyFixture = ({ command = "Talk", overlay = false } = {}) => {
+  const files = new Map(), requested = [];
+  const product = (path, name, subject, own, objects = {}) => {
+    const entries = {};
+    for (const [file, value] of Object.entries(own)) {
+      const asset = `assets/${path.replaceAll("/", "_")}_${file.replaceAll("/", "_")}`;
+      const bytes = value instanceof Uint8Array ? value : encoder.encode(JSON.stringify(value));
+      files.set(asset, bytes);
+      entries[file] = { asset, size: bytes.byteLength };
+    }
+    const manifest = { schema: "nnnotes.product/1", product: name, subject, files: entries, objects };
+    files.set(path, encoder.encode(JSON.stringify(manifest)));
+    return manifest;
+  };
+  const parts = { scene: "storyscenes/default.json", models: { "Character/Live2D/g/m/model/m": "models/m.json" },
+    assets: { "Adv/Stage/a": "storyassets/a.json" }, sounds: { sheet: "cuesheets/sheet.json" },
+    videos: { "Cri/Video/movie": "videos/movie.json" },
+    ui: { ja: "storyui/ja.json", en: "storyui/en.json" }, fonts: { ja: "storyfonts/7_ja.json", en: "storyfonts/7_en.json" } };
+  if (overlay) {
+    parts.simpleui = { ja: "storysimpleui/ja.json", en: "storysimpleui/en.json" };
+    parts.host = { afterlive: "storyhosts/afterlive.json" };
+    product(parts.simpleui.ja, "story.simpleui", "ja", { "ui.json": { format: "nnnotes.story-simple-ui/1" } });
+    product(parts.host.afterlive, "story.host", "afterlive", { "host.json": { format: "nnnotes.story-host/1", kind: "afterlive" } });
+  }
+  const episode = { advId: 7, master: { _playbackMode: overlay ? 1 : 0 }, title: { japanese: "Example", english: "Test" },
+    commands: [{ cmd: command }] };
+  product("stories/7.json", "story", "7", { "story.json": { format: 1, advId: 7, episode: "episode.json", parts }, "episode.json": episode });
+  product(parts.scene, "story.scene", "default", { "scene.json": { format: 1, scene: ["cab:1"] } });
+  product(parts.ui.ja, "story.ui", "ja", { "ui.json": { format: 1, language: { code: "ja" } } });
+  product(parts.fonts.ja, "story.fonts", "7/ja", { "fonts.json": { format: "nnnotes.story-fonts/1", textures: {} } });
+  product(parts.models["Character/Live2D/g/m/model/m"], "live2d.model", "Character/Live2D/g/m/model/m", { "model.json": { format: 3, name: "m" } });
+  product(parts.assets["Adv/Stage/a"], "story.asset", "Adv/Stage/a", { "asset.json": { format: 1, prefab: "cab:2" } });
+  product(parts.sounds.sheet, "story.sound", "sheet", { "cues.json": { voice: { file: "voice.m4a", categories: ["Voice", "VoiceConfig"] } },
+    "voice.m4a": new Uint8Array([1, 2]) });
+  product(parts.videos["Cri/Video/movie"], "story.video", "Cri/Video/movie", { "video.json": { format: 1, file: "movie.webm" },
+    "movie.webm": new Uint8Array([3]) });
+  const fetch = async (url) => {
+    requested.push(String(url));
+    const bytes = files.get(String(url).slice(STORY_ROOT.length));
+    return bytes ? new Response(bytes) : new Response(null, { status: 404 });
+  };
+  return { files, requested, fetch, parts, product };
+};
diff --git a/tests/unit/story-products.test.mjs b/tests/unit/story-products.test.mjs
new file mode 100644
index 0000000..20914ca
--- /dev/null
+++ b/tests/unit/story-products.test.mjs
@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { StoryData } from "../../src/story/data.js";
+import { fetchStoryProduct, loadStoryProducts } from "../../src/story/store.js";
+
+import { STORY_ROOT as ROOT, storyFixture as fixture } from "./story-product-fixture.mjs";
+
+test("story products load one language and resolve model, asset, cue and video files", async () => {
+  const f = fixture();
+  const store = await loadStoryProducts(`${ROOT}stories/7.json`, { fetch: f.fetch, lang: "ja" });
+  const data = new StoryData(store);
+  assert.equal(data.episode.advId, 7);
+  assert.deepEqual(store.info.story.titles, { ja: "Example", en: "Test" });
+  assert.equal(data.ui.language.code, "ja");
+  assert.equal(data.fontDir, "storyfonts/7_ja");
+  assert.deepEqual(data.scene.scene, ["cab:1"]);
+  assert.equal(data.model("Character/Live2D/g/m/model/m").dir, "models/m");
+  assert.equal(data.asset("Adv/Stage/a").prefab, "cab:2");
+  assert.equal(data.cues("sheet").voice.file, "cuesheets/sheet/voice.m4a");
+  assert.deepEqual(data.cues("sheet").voice.categories, ["Voice", "VoiceConfig"]);
+  assert.equal(data.video("Cri/Video/movie").file, "videos/movie/movie.webm");
+  assert.equal(data.host, null);
+  assert.ok(!f.requested.some((url) => url.endsWith("/en.json") || url.endsWith("7_en.json")));
+  assert.equal(new Set(f.requested).size, f.requested.length);
+});
+
+test("Overlay products include their host and simple UI", async () => {
+  const f = fixture({ overlay: true });
+  const data = new StoryData(await loadStoryProducts(`${ROOT}stories/7.json`, { fetch: f.fetch, lang: "ja" }));
+  assert.equal(data.host.kind, "afterlive");
+  assert.equal(data.simpleui.format, "nnnotes.story-simple-ui/1");
+});
+
+test("unsupported commands fail before fetching scene or media products", async () => {
+  const f = fixture({ command: "UnknownCommand" });
+  await assert.rejects(fetchStoryProduct(`${ROOT}stories/7.json`, { fetch: f.fetch }), /UnknownCommand/);
+  assert.ok(!f.requested.some((url) => url.includes("storyscenes") || url.includes("cuesheets")));
+});
+
+test("language and product identities are checked before combining data", async () => {
+  const f = fixture();
+  await assert.rejects(loadStoryProducts(`${ROOT}stories/7.json`, { fetch: f.fetch }), /language is required/);
+  await assert.rejects(loadStoryProducts(`${ROOT}stories/7.json`, { fetch: f.fetch, lang: "ko" }), /no ui for language ko/);
+  f.product(f.parts.ui.ja, "story.ui", "en", { "ui.json": { format: 1 } });
+  await assert.rejects(loadStoryProducts(`${ROOT}stories/7.json`, { fetch: f.fetch, lang: "ja" }), /expected story.ui product of ja/);
+});
+
+test("an already fetched index is reused and cancellation is observed", async () => {
+  const f = fixture();
+  const head = await fetchStoryProduct(`${ROOT}stories/7.json`, { fetch: f.fetch });
+  const store = await loadStoryProducts(head.url, { head, lang: "ja" });
+  assert.equal(store.info.loadedLanguage, "ja");
+  assert.equal(f.requested.filter((url) => url === head.url).length, 1);
+  const controller = new AbortController();
+  controller.abort(new Error("cancelled"));
+  await assert.rejects(loadStoryProducts(head.url, { head, lang: "ja", signal: controller.signal }), /cancelled/);
+});
diff --git a/tests/unit/story-renderer.test.mjs b/tests/unit/story-renderer.test.mjs
index 3f78865..3a2e7f8 100644
--- a/tests/unit/story-renderer.test.mjs
+++ b/tests/unit/story-renderer.test.mjs
@@ -13,9 +13,9 @@ import { AdvCamera } from "../../src/story/field.js";
 import { StoryRenderer } from "../../src/story/renderer.js";
 import { headlessGL } from "../../scripts/lib/headless.mjs";
 
-const cameraNode = (extra = {}) => ({ path: "CameraManager/MainCamera", components: [{ type: "Camera",
+const cameraNode = (extra = {}) => ({
   "near clip plane": 0.3, "far clip plane": 5000, "field of view": 60, orthographic: false, "orthographic size": 2,
-  m_BackGroundColor: { r: 1, g: 1, b: 1, a: 1 }, ...extra }] });
+  m_BackGroundColor: { r: 1, g: 1, b: 1, a: 1 }, ...extra });
 
 // a program with the given default-block uniforms ([name, type, size]) and one uniform block of vec4 / matrix members
 // ([name, offset in bytes]), as UnityProgram reads a linked program's inputs
diff --git a/tests/unit/story-schema.test.mjs b/tests/unit/story-schema.test.mjs
index f2c4d4e..a101a7b 100644
--- a/tests/unit/story-schema.test.mjs
+++ b/tests/unit/story-schema.test.mjs
@@ -1,8 +1,4 @@
-// The story schemas (schema/stor*.schema.json, episode.schema.json) and the story checks of scripts/validate-data.mjs
-// on a synthetic story site built here: two language groups, one cue sheet with a FLAC waveform, one glyph page per
-// language, a UI shader directory with the distance-field shader; variants with a host (an Overlay story), with chat
-// window, dialog and frame texts, with a missing glyph, with a fallback font asset and with an emoji sprite asset.
-// No game data.
+// Product schemas and validation of synthetic story graphs, fonts, audio and model dependencies.
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
@@ -11,648 +7,216 @@ import path from "node:path";
 import { test } from "node:test";
 import { fileURLToPath } from "node:url";
 import { compile } from "../../scripts/lib/json-schema.mjs";
-import { encode, modelObjects, modelProduct, productSize, putFiles, sha256 } from "./site-fixture.mjs";
+import { ADV_COMMAND } from "../../src/story/interfaces.js";
+import { validationFixture, writeFixture, withMissingGlyph, withFallback, GL_SOURCE } from "./story-validation-fixture.mjs";
+import { png } from "./site-fixture.mjs";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-const script = path.join(here, "..", "..", "scripts", "validate-data.mjs");
-const schema = (name) => compile(JSON.parse(fs.readFileSync(path.join(here, "..", "..", "schema", `${name}.schema.json`), "utf8")));
-
-// ------------------------------------------------------------------------------------------------ file contents
-const png = (w, h) => {
-  const b = Buffer.alloc(33);
-  Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).copy(b, 0);
-  b.writeUInt32BE(13, 8); b.write("IHDR", 12, "latin1"); b.writeUInt32BE(w, 16); b.writeUInt32BE(h, 20);
-  b[24] = 8; b[25] = 6;
-  return b;
-};
-const flac = (sampleRate, channels, samples) => {
-  const b = Buffer.alloc(42);
-  b.write("fLaC", 0, "latin1"); b[4] = 0; b[7] = 34;
-  const s = b.subarray(8);
-  s[10] = sampleRate >> 12; s[11] = (sampleRate >> 4) & 0xff; s[12] = ((sampleRate & 0xf) << 4) | ((channels - 1) << 1);
-  s[13] = (15 << 4) | Math.floor(samples / 2 ** 32); s.writeUInt32BE(samples % 2 ** 32, 14);
-  return b;
-};
-const glsl = "#ifdef VERTEX\n#version 300 es\nvoid main() {}\n#endif\n#ifdef FRAGMENT\n#version 300 es\nvoid main() {}\n#endif\n";
-const TMP = "TextMeshPro/Mobile/Distance Field";
-
-const texts = (s) => ({ japanese: s, english: s, traditionalChinese: s, simplifiedChinese: s, korean: s });
-const episode = () => ({
-  advId: 7, asset: "adv_script_7", commandCount: 3,
-  commands: [{ i: 0, cmd: "Bgm", raw: 15, BgmID: 1 }, { i: 1, cmd: "Talk", raw: 2, TargetName: "a", AdvTextID: "t1", VoiceIDs: [2] },
-             { i: 2, cmd: "Shake", raw: 4, IgnoreData: 1 }],
-  text: { t1: texts("Hi") }, sounds: { 1: { _soundCueSheetID: 5, _cueName: "bgm_a" }, 2: { _soundCueSheetID: 5, _cueName: "voice_a" } },
-  cuesheets: { 5: { _cueSheetName: "sheet_a" } }, videos: {}, resources: [{ kind: "episode", address: "adv_script_7", present: true }],
-  master: { _id: 7, _sheetName: "s", _advEpisodeAsset: "adv_script_7", _titleTextId: "t0", _rubyTitleTextId: "", _playbackMode: 0 },
-  title: texts("T"),
-});
-const scene = () => ({ player: {}, settings: { playerSettings: { _initializeEpisodes: [{ Command: 35 }], _finalizeEpisodes: [] } } });
-const shaderIndex = (names) => names.map((n, i) => ({ name: n, parsed: `s${i}.json`,
-  variants: [{ file: `s${i}_0.glsl`, subShader: 0, pass: 0, keywords: [] }, { file: `s${i}_1.glsl`, subShader: 0, pass: 0, keywords: ["OUTLINE_ON"] }] }));
-const shaderFiles = (dir, names) => {
-  const out = { [`${dir}/shaders.json`]: shaderIndex(names) };
-  names.forEach((n, i) => { out[`${dir}/s${i}.json`] = { subShaders: [{ passes: [{ state: {} }] }] }; out[`${dir}/s${i}_0.glsl`] = glsl; out[`${dir}/s${i}_1.glsl`] = glsl; });
-  return out;
-};
-const ui = () => ({ nodes: [{ path: "W" }, { path: "W/Talk", textStyle: { fontRole: "primary" } }],
-                    textures: { sprites: { texture: "textures/sprites.png", name: "sprites", width: 8, height: 4, mipCount: 1 } },
-                    materials: { "Default UI Material": { material: "Default UI Material", shader: { shader: "UI/Default" } } },
-                    materialKeywords: { "Default UI Material": [] } });
-const font = (lang) => {
-  const page = `font_Test ${lang}_0`;
-  const face = Object.fromEntries(["m_PointSize", "m_Scale", "m_UnitsPerEM", "m_LineHeight", "m_AscentLine", "m_CapLine", "m_MeanLine", "m_Baseline",
-    "m_DescentLine", "m_SuperscriptOffset", "m_SuperscriptSize", "m_SubscriptOffset", "m_SubscriptSize", "m_UnderlineOffset",
-    "m_UnderlineThickness", "m_StrikethroughOffset", "m_StrikethroughThickness", "m_TabWidth"].map((k) => [k, 1]));
-  return {
-    page,
-    doc: {
-      format: "ournotes.story-fonts/1", language: lang, source: "open",
-      fonts: { "Test SDF": {
-        faceInfo: { ...face, m_FamilyName: "Test", m_StyleName: "Regular", m_FaceIndex: 0 },
-        atlasWidth: 16, atlasHeight: 16, atlasPadding: 1, atlasRenderMode: 4134, atlasPopulationMode: 0, atlases: [page],
-        normalStyle: 0, normalSpacingOffset: 0, boldStyle: 0.75, boldSpacing: 7, italicStyle: 35, tabSize: 10,
-        material: "Test SDF Material", fallbacks: [], glyphPairAdjustmentRecords: 0,
-        characters: { 72: { glyph: 3, scale: 1, elementType: 1 }, 32: { glyph: 1, scale: 1, elementType: 1 } },
-        glyphs: { 3: { metrics: { m_Width: 4, m_Height: 5, m_HorizontalBearingX: 0, m_HorizontalBearingY: 5, m_HorizontalAdvance: 5 },
-                       rect: { m_X: 2, m_Y: 2, m_Width: 4, m_Height: 5 }, scale: 1, atlasIndex: 0, packed: { texture: page, dx: 0, dy: 0 } },
-                  1: { metrics: { m_Width: 0, m_Height: 0, m_HorizontalBearingX: 0, m_HorizontalBearingY: 0, m_HorizontalAdvance: 3 },
-                       rect: { m_X: 0, m_Y: 0, m_Width: 0, m_Height: 0 }, scale: 1, atlasIndex: 0 } },
-        runtimeCharacters: [], runtimeGlyphs: null, subset: "the characters shown",
-        source: { family: "Test", style: "Regular", version: "1", license: "OFL", file: "t.ttf", faceIndex: 0, bytes: 1, sha256: "0".repeat(64), generator: {} } } },
-      textures: { [page]: { texture: `fonts/${page}.png`, name: page, width: 16, height: 12, mipCount: 1,
-                            settings: { m_FilterMode: 1, m_WrapU: 1, m_WrapV: 1 } } },
-      materials: { "Test SDF Material": { material: "Test SDF Material", shader: { shader: TMP }, keywords: [], textures: {}, floats: {}, colors: {} },
-                   "Test - Outline": { material: "Test - Outline", shader: { shader: TMP }, keywords: ["OUTLINE_ON"], textures: {}, floats: {}, colors: {} } },
-      materialKeywords: { "Test SDF Material": [], "Test - Outline": ["OUTLINE_ON"] },
-      texts: { "W/Talk": { class: "TextMeshProUGUI", enabled: 1, fontAsset: "Game SDF", material: "Game - Outline", m_fontSize: 40, m_text: "",
-                           localized: { fontAsset: "Test SDF", material: "Test - Outline", lineSpacing: 0 } } },
-      coverage: { characters: 2, missing: [] },
-      lineBreaking: { leading: "(", following: ")", useModernHangulLineBreakingRules: false },
-    },
-  };
-};
-const language = (lang, mode, field) => ({ format: "ournotes.story-language/1", language: lang, mode, field, lineSpacing: 0, fonts: "open",
-  roles: { primary: { fontAsset: "Test SDF", lineHeightEm: 1, ascentEm: 0.8, descentEm: -0.2, spacingOffset: 0, boldSpacing: 7 } } });
-
-// ------------------------------------------------------------------------------------------------ the site
-// logical files -> a content-addressed site with stories/7.json and stories.json; `edit(parts)` changes the pieces
-// before they are stored:
-//   common, groups, man   the story's common files, language groups and manifest keys
-//   models                model id -> its objects and model.json (site-fixture modelObjects; its product manifest
-//                         models/<id>.json; the manifest's models list them all)
-//   modelsIndex           write models.json listing the models (true), or the ids of a list
-//   encoding              "gzip" | "br": every compressible asset encoded where that is smaller
-//   where                 the manifest's path (stories/7.json; stories/<region>/7.json for a region's own)
-//   index                 false: no stories.json; a function: edits the stories.json entry
-function buildSite(edit = () => {}) {
-  const common = {
-    "story.json": { advId: 7, episode: "episode.json", scene: "scene.json", ui: "ui/ui.json", models: {}, audio: { sheet_a: "audio/sheet_a" },
-                    frames: null, effects: null, postEffects: null, stills: null, talkWindows: null, chat: null, videos: null },
-    "episode.json": episode(), "scene.json": scene(),
-    "audio/sheet_a/cues.json": { bgm_a: { file: "bgm_a.flac", sampleRate: 48000, channels: 2, samples: 96000, loopStart: 0, loopEnd: 96000 },
-                                 voice_a: { file: "voice_a.flac", sampleRate: 48000, channels: 1, samples: 4800 } },
-    "audio/sheet_a/bgm_a.flac": flac(48000, 2, 96000), "audio/sheet_a/voice_a.flac": flac(48000, 1, 4800),
-    "ui/ui.json": ui(), "ui/textures/sprites.png": png(8, 4),
-    ...shaderFiles("ui/shaders", [TMP, "UI/Default"]),
-  };
-  const groups = {};
-  for (const [lang, mode, field] of [["ja", 0, "japanese"], ["en", 1, "english"]]) {
-    const f = font(lang);
-    groups[lang] = { "ui/fonts.json": f.doc, [`ui/fonts/${f.page}.png`]: png(16, 12), "ui/languages.json": language(lang, mode, field) };
-  }
-  const facts = { advId: 7, asset: "adv_script_7", sheetName: "s", playbackMode: 0, titles: { ja: "T", en: "T" }, groups: [],
-                  commands: ["Bgm", "TalkWindow", "Talk"].sort(), commandCount: 3, language: "en", languages: ["ja", "en"] };
-  const man = { format: "ournotes.story-manifest/2", advId: 7, root: "../", story: facts, language: "en", audio: true, audioFormat: "flac",
-                fonts: "open", requires: { commands: facts.commands, cubismCore: true, motionSync: true } };
-  const parts = { common, groups, man, index: true, models: {}, modelsIndex: false, encoding: null, where: "stories/7.json" };
-  edit(parts);
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "ournotes-story-"));
-  const entries = (files) => putFiles(dir, files, parts.encoding);
-  const ids = Object.keys(parts.models).sort(), modelSize = {};
-  fs.mkdirSync(path.join(dir, "models"), { recursive: true });
-  for (const id of ids) {
-    const mm = modelProduct(dir, parts.models[id], parts.encoding);
-    modelSize[id] = productSize(mm);
-    fs.writeFileSync(path.join(dir, "models", `${id}.json`), JSON.stringify(mm));
-  }
-  if (parts.modelsIndex) {
-    const listed = Array.isArray(parts.modelsIndex) ? parts.modelsIndex : ids;
-    fs.writeFileSync(path.join(dir, "models.json"), JSON.stringify({ format: 2, models: listed.map((id) => ({ id, manifest: `models/${id}.json` })) }));
-  }
-  const m = { models: Object.fromEntries(ids.map((id) => [id, `models/${id}.json`])), ...parts.man,
-              files: entries(parts.common),
-              languages: Object.fromEntries(Object.entries(parts.groups).map(([l, g]) => [l, { files: entries(g) }])) };
-  fs.mkdirSync(path.dirname(path.join(dir, parts.where)), { recursive: true });
-  fs.writeFileSync(path.join(dir, parts.where), JSON.stringify(m));
-  if (parts.index) {
-    const size = (files) => Object.values(files).reduce((n, f) => n + f.size, 0);
-    const entry = { id: "7", manifest: parts.where, audio: m.audio, audioFormat: m.audioFormat, fonts: m.fonts, ...m.story,
-                    size: { common: size(m.files), models: ids.reduce((n, id) => n + modelSize[id], 0),
-                            languages: Object.fromEntries(Object.entries(m.languages).map(([l, g]) => [l, size(g.files)])) } };
-    if (typeof parts.index === "function") parts.index(entry);
-    fs.writeFileSync(path.join(dir, "stories.json"), JSON.stringify({ format: "ournotes.stories/1", language: "en", languages: ["ja", "en"], stories: [entry] }));
-  }
-  return { dir, man: m };
-}
-
-// the ja fonts document of a site built with `edit`
-const buildSiteFonts = (edit) => {
-  let doc = null;
-  const { dir } = buildSite((p) => { edit(p); doc = p.groups.ja["ui/fonts.json"]; });
-  fs.rmSync(dir, { recursive: true, force: true });
-  return doc;
-};
-
-// validates the site built with `edit`, after `after(dir, man)` changed the stored site (files on disk)
-const validateBuilt = (edit, after = null, ...args) => {
-  const { dir, man } = buildSite(edit);
+const validator = path.join(here, "../../scripts/validate-data.mjs");
+const schema = (name) => compile(JSON.parse(fs.readFileSync(path.join(here, `../../schema/${name}.schema.json`), "utf8")));
+const validate = (edit = () => {}, after = null, args = []) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "story-validation-"));
   try {
-    if (after) after(dir, man);
-    const r = spawnSync(process.execPath, [script, dir, ...args], { encoding: "utf8" });
-    return { status: r.status, lines: r.stdout.split("\n").map((l) => l.trim()).filter(Boolean), stderr: r.stderr };
+    const fixture = validationFixture(); edit(fixture);
+    const manifests = writeFixture(dir, fixture);
+    after?.(dir, manifests, fixture);
+    const r = spawnSync(process.execPath, [validator, dir, ...args], { encoding: "utf8" });
+    return { status: r.status, text: r.stdout + r.stderr };
   } finally { fs.rmSync(dir, { recursive: true, force: true }); }
 };
-
-const validate = (edit, ...args) => {
-  const { dir } = buildSite(edit);
-  try {
-    const r = spawnSync(process.execPath, [script, dir, ...args], { encoding: "utf8" });
-    return { status: r.status, lines: r.stdout.split("\n").map((l) => l.trim()).filter(Boolean), stderr: r.stderr };
-  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-};
-const failsWith = (edit, text) => {
-  const r = validate(edit);
-  assert.equal(r.status, 1, r.lines.join("\n"));
-  assert.ok(r.lines.some((l) => l.includes(text)), `"${text}" in:\n${r.lines.join("\n")}`);
-};
-
-// an Overlay story with its host: host/host.json (common), ui/simple/ui.json and per language ui/simple/fonts.json
-const withHost = (p, kind = "home") => {
-  p.common["episode.json"].master._playbackMode = 1;
-  p.man.story.playbackMode = 1;
-  p.man.host = { kind, doc: "host/host.json", ui: "ui/simple/ui.json" };
-  p.common["host/host.json"] = { format: "ournotes.story-host/1", kind, ui: "host/ui/ui.json" };
-  p.common["host/ui/ui.json"] = { nodes: [] };
-  p.common["ui/simple/ui.json"] = { nodes: [{ path: "S" }, { path: "S/Text", textStyle: { fontRole: "primary" } }] };
-  for (const lang of ["ja", "en"]) {
-    const f = font(lang);
-    f.doc.texts = { "S/Text": f.doc.texts["W/Talk"] };
-    p.groups[lang]["ui/simple/fonts.json"] = f.doc;
-    p.groups[lang][`ui/simple/fonts/${f.page}.png`] = png(16, 12);
+const passes = (edit, args) => { const r = validate(edit, null, args); assert.equal(r.status, 0, r.text); return r; };
+const fails = (edit, message, after = null) => { const r = validate(edit, after); assert.equal(r.status, 1, r.text); assert.match(r.text, message); };
+const editObject = (f, id, fn) => {
+  const value = JSON.parse(f.o.objects[id].files.json); fn(value); f.o.objects[id].files.json = JSON.stringify(value);
+};
+const fontEdit = (fn) => (f) => fn(f.fonts.ja, f);
+
+test("schemas describe the product index, scene, UI, font bindings and episode", () => {
+  const f = validationFixture();
+  for (const [name, value] of [["story", f.story], ["story-scene", f.scene], ["story-ui", f.ui.ja], ["story-fonts", f.fonts.ja], ["episode", f.episode]])
+    assert.deepEqual(schema(name)(value), [], name);
+  assert.ok(schema("story")({ ...f.story, format: 99 }).length);
+  assert.ok(schema("story-fonts")({ ...f.fonts.ja, texts: { [f.textId]: { localized: {}, style: {} } } }).some((e) => e.includes("font")));
+});
+
+test("valid story products validate in every language", () => {
+  assert.match(passes().text, /1\/1 stories valid/);
+  assert.match(passes(undefined, ["--lang=ja"]).text, /languages: ja/);
+});
+
+test("language selection is explicit and product subjects match each language", () => {
+  fails(f => { f.manifest.language = "ko"; }, /default language ko/);
+  fails(f => { delete f.story.parts.fonts.en; }, /languages differ/);
+  fails(f => { f.products.get(f.story.parts.ui.ja).subject = "en"; }, /expected story.ui product of ja/);
+  const onlyJa = f => { f.products.delete(f.story.parts.ui.en); f.products.delete(f.story.parts.fonts.en); };
+  fails(onlyJa, /ENOENT/);
+  passes(onlyJa, ["--lang", "ja"]);
+  assert.equal(validate(undefined, null, ["--lang=xx"]).status, 2);
+});
+
+test("scene and UI references identify objects of their expected classes", () => {
+  fails(f => { f.scene.prefabs.cameraManager = "missing:1"; }, /object missing:1 not in the store/);
+  fails(f => { f.scene.prefabs.cameraManager = f.texture; }, /a Texture2D, not a GameObject/);
+  fails(f => { f.ui.ja.settings.tmpSettings = f.texture; }, /a Texture2D, not a MonoBehaviour/);
+  fails(f => { f.ui.en.language.field = "japanese"; }, /language code\/field differs/);
+  fails(f => { f.ui.en.language.mode = 0; }, /language code\/field differs/);
+});
+
+test("episode subjects, row counts and executed commands are checked", () => {
+  fails(f => { f.episode.advId = 8; }, /subject disagree/);
+  fails(f => { f.episode.commandCount++; }, /commandCount differs/);
+  fails(f => { f.episode.commands.push({ i: 2, cmd: "UnknownCommand", raw: 999 }); f.episode.commandCount++; }, /unsupported commands: UnknownCommand/);
+  passes(f => { f.episode.commands.push({ i: 2, cmd: "UnknownCommand", raw: 999, IgnoreData: 1 }); f.episode.commandCount++; });
+  fails(f => editObject(f, f.player, x => { x._initializeEpisodes = [{ Command: 999 }]; }), /AdvCommand 999/);
+});
+
+test("cue sheets and waveforms agree with episode sound rows", () => {
+  fails(f => { f.episode.sounds[1]._soundCueSheetID = 9; }, /cue sheet not in parts.sounds/);
+  fails(f => { f.episode.sounds[1]._cueName = "missing"; }, /cue missing not in sheet_a/);
+  fails(f => { delete f.products.get(f.story.parts.sounds.sheet_a).files["a.flac"]; }, /a.flac missing/);
+  fails(f => { f.cues.bgm_a.samples = 49; }, /FLAC total samples 48/);
+  fails(f => { f.cues.bgm_a.sampleRate = 44100; }, /FLAC sample rate 48000/);
+  fails(f => { f.cues.bgm_a.loopStart = 10; f.cues.bgm_a.loopEnd = 100; }, /loop points outside/);
+  fails(f => { f.cues.bgm_a.encoderDelay = 1; }, /invalid encoderDelay/);
+  fails(f => { f.cues.bgm_a.categories = "Bgm"; }, /categories must be an array/);
+});
+
+test("fonts bind TMP component ids to the selected font and material", () => {
+  fails(f => { delete f.fonts.ja.texts[f.textId]; }, /has no font binding/);
+  fails(f => { f.fonts.ja.texts["missing:1"] = f.fonts.ja.texts[f.textId]; }, /not a TMP component/);
+  fails(fontEdit((d, f) => { d.texts[f.textId].font.fontAsset = "Absent"; }), /font asset Absent not in fonts/);
+  fails(fontEdit((d, f) => { d.texts[f.textId].font.material = "Absent"; }), /material Absent not in materials/);
+  passes(fontEdit((d, f) => { d.texts[f.textId].localized = { fontAsset: "Source", material: "Source", lineSpacing: 0 }; }));
+});
+
+test("font glyphs fit their declared PNG pages", () => {
+  fails(fontEdit(d => { d.fonts["Test SDF"].characters[72].glyph = 99; }), /glyph 99 not in glyphs/);
+  fails(fontEdit(d => { d.fonts["Test SDF"].glyphs[3].packed.dx = 16; }), /rect \+ offset leaves page/);
+  fails(fontEdit(d => { delete d.fonts["Test SDF"].glyphs[3].packed; }), /rect without packed texels/);
+  fails(fontEdit(d => { Object.values(d.textures)[0].width = 32; }), /dimensions\/mip count differ/);
+  fails(f => { delete f.products.get(f.story.parts.fonts.ja).files["fonts/font_Test ja_0.png"]; }, /missing/);
+});
+
+test("font shader variants and selected program files are present", () => {
+  fails(fontEdit(d => { d.materials["Test - Outline"].shader.shader = "Absent"; }), /Absent not in the index/);
+  fails(fontEdit(d => { delete d.materialKeywords["Test - Outline"]; }), /no materialKeywords/);
+  fails(f => { const object = f.o.objects[f.shader]; delete object.files[Object.keys(object.files).find(k => k.startsWith("program:") && k.endsWith("1"))]; }, /selected shader program missing/);
+  fails(f => { const object = f.o.objects[f.shader]; object.files[Object.keys(object.files).find(k => k.startsWith("program:"))] = "invalid"; }, /VERTEX/);
+});
+
+test("missing glyph records describe absent characters and the configured substitute", () => {
+  passes(withMissingGlyph);
+  const edit = fn => f => { withMissingGlyph(f); fn(f.fonts.ja, f); };
+  fails(edit(d => { d.fonts["Test SDF"].missingGlyph.characters = [72]; d.coverage.missingGlyph = ["H"]; }), /held by the asset/);
+  fails(edit(d => { delete d.fonts["Test SDF"].characters[0x25a1]; }), /held by neither/);
+  fails(edit(d => { d.fonts["Test SDF"].missingGlyph.characters.reverse(); }), /not ascending/);
+  fails(edit(d => { delete d.coverage.missingGlyph; }), /coverage.missingGlyph differs/);
+  fails(edit(d => { d.fonts["Test SDF"].missingGlyph.unicode = 32; }), /TextMeshPro draws U\+25A1/);
+  passes(edit((d, f) => { editObject(f, f.tmp, x => { x.m_missingGlyphCharacter = 32; }); for (const x of Object.values(f.fonts)) x.fonts["Test SDF"].missingGlyph.unicode = 32; }));
+});
+
+test("fallback font materials preserve inherited properties and recomputed ratios", () => {
+  passes(withFallback);
+  const edit = fn => f => { withFallback(f); fn(f.fonts.ja); };
+  const name = "Test - Outline + Fb SDF";
+  fails(edit(d => { delete d.materials[name]; delete d.materialKeywords[name]; }), /fallback Fb SDF.*not in materials/);
+  fails(edit(d => { d.materials[name].floats._GradientScale = 5; }), /_GradientScale/);
+  fails(edit(d => { d.materials[name].floats._ScaleRatioA = 0.8; }), /_ScaleRatioA not as/);
+  fails(edit(d => { d.materials[name].floats._OutlineWidth = 0.3; }), /_OutlineWidth not as/);
+  fails(edit(d => { d.materials[name].textures._MainTex.texture.name = "wrong"; }), /_MainTex not as/);
+  fails(edit(d => { d.fonts["Test SDF"].fallbacks.push("Test SDF"); }), /fallbacks list the asset itself/);
+});
+
+const withSprites = f => {
+  const name = "TextMeshPro/Sprite", shader = f.o.shader(name, { properties: [], subShaders: [{ passes: [{ state: {} }] }] }, [[[], GL_SOURCE]]);
+  for (const [lang, d] of Object.entries(f.fonts)) {
+    const page = "sprite", source = f.products.get(f.story.parts.fonts[lang]); source.objects[shader] = f.o.objects[shader];
+    d.shaders[name] = shader;
+    d.materials.Sprite = { material: "Sprite", shader: { shader: name }, keywords: [], textures: {}, floats: {}, colors: {} };
+    d.materialKeywords.Sprite = [];
+    const glyph = structuredClone(d.fonts["Test SDF"].glyphs[3]); glyph.packed.texture = page;
+    d.spriteAssets = { Emoji: { faceInfo: { m_PointSize: 0, m_Scale: 1, m_Baseline: 0, m_AscentLine: 0, m_DescentLine: 0 },
+      material: "Sprite", sequences: [], characters: [{ index: 0, unicode: 0x1f600, name: "1f600", glyph: 0, scale: 1 }], glyphs: { 0: glyph } } };
+    d.emojiSpriteAsset = "Emoji"; d.sprites[f.textId] = { spriteAsset: "Emoji" }; d.coverage.sprites = { characters: 1, missing: [] };
+    d.textures[page] = { texture: "fonts/sprite.png", name: page, width: 16, height: 12, mipCount: 1, settings: { m_FilterMode: 1, m_WrapU: 1, m_WrapV: 1 } };
+    source.files["fonts/sprite.png"] = png(16, 12);
   }
 };
-// chat window texts: a text record per text in ui.json chatTexts, a binding per text in each fonts.json chatTexts
-const withChat = (p) => {
-  p.common["ui/ui.json"].chatTexts = { Line: { "Line/Top/Name": { textStyle: { fontRole: "font2" }, localizeText: null } } };
-  for (const lang of ["ja", "en"]) {
-    const f = p.groups[lang]["ui/fonts.json"];
-    f.chatTexts = { Line: { "Line/Top/Name": { ...f.texts["W/Talk"], fontAsset: "Chat SDF", m_monospaceDistEm: 0 } } };
-  }
-};
-
-// a dialog of the ADV screen: its text node in ui.json dialogs, a binding per language in fonts.json dialogTexts
-const withDialog = (p) => {
-  p.common["ui/ui.json"].dialogs = { Skip: { key: "EmbUI/Prefab/Skip", nodes: [{ path: "Skip" }, { path: "Skip/Message", textStyle: {} }] } };
-  for (const lang of ["ja", "en"]) {
-    const f = p.groups[lang]["ui/fonts.json"];
-    f.dialogTexts = { Skip: { "Skip/Message": f.texts["W/Talk"] } };
-  }
-};
-
-// frames.json with a frame whose prefab has a text node (and one without), a binding per language in frameTexts
-const withFrames = (p) => {
-  p.common["story.json"].frames = "frames.json";
-  p.common["frames.json"] = { frames: {
-    Comment: { nodes: [{ path: "Comment", components: [{ class: "AdvFrame" }] },
-                       { path: "Comment/Body", components: [{ type: "RectTransform" }, { class: "TextMeshProUGUI", m_text: "" }] }] },
-    Plain: { nodes: [{ path: "Plain", components: [{ class: "AdvFrame" }] }] } } };
-  for (const lang of ["ja", "en"]) {
-    const f = p.groups[lang]["ui/fonts.json"];
-    f.frameTexts = { Comment: { "Comment/Body": structuredClone(f.texts["W/Talk"]) } };
-  }
-};
-
-// the missing glyph: U+2661 and U+FE0F drawn as U+25A1, which the font asset holds
-const HEART = 0x2661, VS16 = 0xFE0F, SQUARE = 0x25A1;
-const withMissingGlyph = (p) => {
-  for (const lang of ["ja", "en"]) {
-    const f = p.groups[lang]["ui/fonts.json"], a = f.fonts["Test SDF"];
-    a.characters[SQUARE] = { glyph: 3, scale: 1, elementType: 1 };
-    a.missingGlyph = { unicode: SQUARE, characters: [HEART, VS16] };
-    f.coverage.missingGlyph = [HEART, VS16].map((u) => String.fromCodePoint(u));
-  }
-};
-
-// a fallback font asset: "Fb SDF" (gradient scale 16) behind "Test SDF" (5), its page and default material, and the
-// fallback material of the text material "Test - Outline"; U+53E3 drawn from it
-const withFallback = (p) => {
-  for (const lang of ["ja", "en"]) {
-    const f = p.groups[lang]["ui/fonts.json"], page = `font_Fb ${lang}_0`, test = f.fonts["Test SDF"];
-    const tex = (name, w, h) => ({ _MainTex: { texture: { name, width: w, height: h, format: 4 } } });
-    f.fonts["Fb SDF"] = { ...structuredClone(test), atlases: [page], atlasPadding: 15, material: "Fb SDF Material", fallbacks: [],
-                          characters: { 21475: { glyph: 3, scale: 1, elementType: 1 } } };
-    f.fonts["Fb SDF"].glyphs = { 3: { ...structuredClone(test.glyphs[3]), packed: { texture: page, dx: 0, dy: 0 } } };
-    test.fallbacks = ["Fb SDF"];
-    f.textures[page] = { texture: `fonts/${page}.png`, name: page, width: 16, height: 12, mipCount: 1,
-                         settings: { m_FilterMode: 1, m_WrapU: 1, m_WrapV: 1 } };
-    p.groups[lang][`ui/fonts/${page}.png`] = png(16, 12);
-    const outline = f.materials["Test - Outline"];
-    Object.assign(outline, { textures: tex(`font_Test ${lang}_0`, 16, 12),
-                             floats: { _GradientScale: 5, _FaceDilate: 0, _OutlineWidth: 0.2, _OutlineSoftness: 0, _WeightNormal: 0,
-                                       _WeightBold: 0.5, _UnderlayOffsetX: 0.5, _UnderlayOffsetY: -0.5, _UnderlayDilate: 0,
-                                       _UnderlaySoftness: 0, _ScaleRatioA: 0.8, _ScaleRatioC: 0.7, _TextureWidth: 16, _TextureHeight: 12 } });
-    f.materials["Fb SDF Material"] = { material: "Fb SDF Material", shader: { shader: TMP }, keywords: [], textures: tex(page, 16, 12),
-                                       floats: { _GradientScale: 16, _WeightNormal: 0, _WeightBold: 0.75, _TextureWidth: 16, _TextureHeight: 12 },
-                                       colors: {} };
-    // GetFallbackMaterial: weight 0.75 / 4, t = max(1, 0.1875 + 0.2) = 1 -> A = 15 / 16; C = (15 - 0.1875 * 15) / 16
-    f.materials["Test - Outline + Fb SDF"] = { ...structuredClone(outline), material: "Test - Outline + Fb SDF", textures: tex(page, 16, 12),
-                                               floats: { ...outline.floats, _GradientScale: 16, _WeightBold: 0.75, _ScaleRatioA: 0.9375,
-                                                         _ScaleRatioC: 0.76171875 } };
-    f.materialKeywords["Fb SDF Material"] = [];
-    f.materialKeywords["Test - Outline + Fb SDF"] = ["OUTLINE_ON"];
-  }
-};
-
-// the emoji sprite asset: two sprites (one without an image), its page and sprite material, the talk text driven by
-// a UIText; the sprite shader in ui/shaders
-const SPRITE = "TextMeshPro/Sprite";
-const withSprites = (p) => {
-  Object.assign(p.common, shaderFiles("ui/shaders", [TMP, "UI/Default", SPRITE]));
-  const metrics = { m_Width: 4, m_Height: 4, m_HorizontalBearingX: 0, m_HorizontalBearingY: 4, m_HorizontalAdvance: 4 };
-  for (const lang of ["ja", "en"]) {
-    const f = p.groups[lang]["ui/fonts.json"], page = "sprite_Emoji";
-    f.spriteAssets = { Emoji: {
-      faceInfo: { m_PointSize: 0, m_Scale: 1, m_Baseline: 0, m_AscentLine: 0, m_DescentLine: 0 },
-      characters: [{ index: 3, unicode: 0x1F600, name: "1f600", glyph: 0, scale: 1 }, { index: 5, unicode: 0x2764, name: "2764", glyph: 1, scale: 1 }],
-      glyphs: { 0: { metrics, rect: { m_X: 1, m_Y: 1, m_Width: 4, m_Height: 4 }, scale: 1, atlasIndex: 0, packed: { texture: page, dx: 0, dy: 0 } },
-                1: { metrics, rect: { m_X: 0, m_Y: 0, m_Width: 0, m_Height: 0 }, scale: 1, atlasIndex: 0 } },
-      sequences: [{ name: "1f469-200d-1f4bb", unicode: 0 }], material: "Emoji Material", source: null, subset: "the sprites shown" } };
-    f.emojiSpriteAsset = "Emoji";
-    f.materials["Emoji Material"] = { material: "Emoji Material", shader: { shader: SPRITE }, keywords: [], textures: {}, floats: {}, colors: {} };
-    f.materialKeywords["Emoji Material"] = [];
-    f.textures[page] = { texture: `fonts/${page}.png`, name: page, width: 8, height: 8, mipCount: 1, settings: { m_FilterMode: 1, m_WrapU: 1, m_WrapV: 1 } };
-    p.groups[lang][`ui/fonts/${page}.png`] = png(8, 8);
-    f.coverage.sprites = { characters: 2, missing: ["2764"] };
-    Object.assign(f.texts["W/Talk"], { spriteAsset: "Emoji", m_tintAllSprites: 0 });
-  }
-};
-
-// ------------------------------------------------------------------------------------------------ tests
-test("the story schemas accept the synthetic documents", () => {
-  const { dir, man } = buildSite();
-  try {
-    assert.deepEqual(schema("story-manifest")(man), []);
-    assert.deepEqual(schema("stories")(JSON.parse(fs.readFileSync(path.join(dir, "stories.json"), "utf8"))), []);
-    assert.deepEqual(schema("episode")(episode()), []);
-    assert.deepEqual(schema("story-fonts")(font("ja").doc), []);
-    assert.deepEqual(schema("story-language")(language("ja", 0, "japanese")), []);
-  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-  assert.ok(schema("story-manifest")({ ...man, format: "ournotes.story-manifest/3" }).some((e) => e.includes("/format")));
-  assert.ok(schema("story-manifest")({ ...man, audioFormat: "ogg" }).some((e) => e.includes("/audioFormat")));
-  assert.ok(schema("episode")({ ...episode(), commands: [{ i: 0, cmd: "Bgm" }] }).some((e) => e.includes("raw")));
-  const f = font("ja").doc;
-  f.texts["W/Talk"].localizeKoreanAdjust = { _koreanFontStyle: 1, m_Enabled: 1 };
-  assert.ok(schema("story-fonts")(f).some((e) => e.includes("localizeKoreanAdjust/m_Enabled")));
-});
-
-test("a valid story site validates", () => {
-  const r = validate();
-  assert.equal(r.status, 0, r.lines.join("\n") + r.stderr);
-  assert.deepEqual(r.lines, ["1/1 stories valid"]);
-  assert.deepEqual(validate((p) => { p.index = false; }).lines, ["1/1 stories valid"]);     // manifests without stories.json
-  assert.equal(validate(undefined, "7").status, 0);
-  const missing = validate(undefined, "8");
-  assert.equal(missing.status, 2);
-  assert.match(missing.stderr, /chart, model or story 8 not found/);
-});
-
-test("language groups: disjoint from the common files, with fonts.json and languages.json, default language among them", () => {
-  failsWith((p) => { p.common["ui/languages.json"] = language("en", 1, "english"); }, "languages.ja: ui/languages.json is also a common file");
-  failsWith((p) => { delete p.groups.en["ui/languages.json"]; }, "languages.en: ui/languages.json missing");
-  failsWith((p) => { p.man.language = "ko"; p.man.story.language = "ko"; }, "language ko is not a key of languages");
-  failsWith((p) => { p.groups.en["ui/fonts.json"].textures[`font_Test en_0`].texture = "fonts/other.png"; }, "not in the language group");
-  failsWith((p) => { p.common["ui/ui.json"].nodes.reverse(); }, "[ja] ui/ui.json: parent of W/Talk is not listed before it");
-});
-
-test("stories.json agrees with the manifest", () => {
-  failsWith((p) => { p.index = (e) => { e.size.common += 1; }; }, "stories.json: size");
-  failsWith((p) => { p.index = (e) => { e.titles = { ja: "X" }; }; }, "stories.json: titles differs");
-  failsWith((p) => { p.index = (e) => { e.audioFormat = "aac"; }; }, "stories.json: audioFormat");
-});
-
-test("commands and lip sync follow the episode", () => {
-  failsWith((p) => { p.man.requires.commands = ["Bgm", "Talk"]; p.man.story.commands = ["Bgm", "Talk"]; p.index = false; }, "the episode runs [\"Bgm\",\"Talk\",\"TalkWindow\"]");
-  failsWith((p) => { p.man.requires.motionSync = false; }, "requires.motionSync false");
-});
-
-test("sounds: cue sheets, waveform files and their headers", () => {
-  failsWith((p) => { p.common["audio/sheet_a/bgm_a.flac"] = flac(44100, 2, 96000); }, "FLAC sample rate 44100, described 48000");
-  failsWith((p) => { delete p.common["audio/sheet_a/voice_a.flac"]; }, "voice_a: audio/sheet_a/voice_a.flac is not a common file");
-  failsWith((p) => { p.common["episode.json"].cuesheets[6] = { _cueSheetName: "sheet_b" }; }, "cue sheet sheet_b of the episode has no audio directory");
-  failsWith((p) => { p.common["audio/sheet_a/cues.json"].bgm_a.loopEnd = 96001; }, "bgm_a: loop points outside the waveform");
-});
-
-test("fonts: bindings, font assets, glyph pages and text material shaders", () => {
-  failsWith((p) => { p.groups.ja["ui/fonts.json"].texts = {}; }, "[ja] ui/fonts.json: text node W/Talk has no binding in texts");
-  failsWith((p) => { p.groups.ja["ui/fonts.json"].texts["W/Talk"].localized.material = "Nope"; }, "material Nope not in materials");
-  failsWith((p) => { p.groups.en["ui/fonts.json"].fonts["Test SDF"].glyphs[3].rect.m_Y = 9; }, "glyph 3: rect + offset leaves page");
-  failsWith((p) => { p.groups.en["ui/fonts/font_Test en_0.png"] = png(16, 16); }, "PNG is 16x16, descriptor font_Test en_0 says 16x12");
-  // the shader uses OUTLINE_ON, but only together with UNDERLAY_ON: no variant draws [OUTLINE_ON] alone
-  failsWith((p) => {
-    p.common["ui/shaders/shaders.json"] = shaderIndex([TMP, "UI/Default"])
-      .map((r) => ({ ...r, variants: [r.variants[0], { ...r.variants[1], keywords: ["OUTLINE_ON", "UNDERLAY_ON"] }] }));
-  }, "material Test - Outline: ui/shaders/shaders.json: TextMeshPro/Mobile/Distance Field: no variant for [OUTLINE_ON]");
-  failsWith((p) => { p.groups.ja["ui/languages.json"].mode = 1; }, "[ja] ui/languages.json: mode 1 / field japanese, ja is 0 / japanese");
-});
-
-test("assets: present, sized and named by their content", () => {
-  const { dir, man } = buildSite();
-  try {
-    const a = man.files["episode.json"].asset;
-    fs.appendFileSync(path.join(dir, a), " ");
-    const r = spawnSync(process.execPath, [script, dir], { encoding: "utf8" });
-    assert.equal(r.status, 1);
-    assert.ok(r.stdout.includes(`episode.json: ${a}:`), r.stdout);
-  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-});
-
-test("host: an Overlay story with open fonts has host/host.json and the simple talk window per language", () => {
-  const { dir, man } = buildSite(withHost);
-  try {
-    assert.deepEqual(schema("story-manifest")(man), []);
-    assert.ok(schema("story-manifest")({ ...man, host: { ...man.host, kind: "live" } }).some((e) => e.includes("/host/kind")));
-    assert.ok(schema("story-manifest")({ ...man, host: { ...man.host, doc: "host.json" } }).some((e) => e.includes("/host/doc")));
-    assert.ok(schema("story-manifest")({ ...man, host: { ...man.host, extra: 1 } }).some((e) => e.includes("/host")));
-  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-  const r = validate(withHost);
-  assert.equal(r.status, 0, r.lines.join("\n") + r.stderr);
-  assert.equal(validate((p) => withHost(p, "afterlive")).status, 0);
-  failsWith((p) => { p.common["episode.json"].master._playbackMode = 1; p.man.story.playbackMode = 1; }, "an Overlay story (playbackMode 1) with open fonts has no host");
-  failsWith((p) => { withHost(p); p.common["episode.json"].master._playbackMode = 0; p.man.story.playbackMode = 0; }, "host on a story of playbackMode 0");
-  failsWith((p) => { withHost(p); p.common["host/host.json"].kind = "afterlive"; }, "host/host.json: kind afterlive, manifest host.kind home");
-  failsWith((p) => { withHost(p); p.common["host/host.json"].format = "ournotes.story-host/2"; }, "expected ournotes.story-host/1");
-  failsWith((p) => { withHost(p); delete p.groups.en["ui/simple/fonts.json"]; }, "languages.en: ui/simple/fonts.json missing (the story has a host)");
-  failsWith((p) => { withHost(p); p.groups.ja["ui/simple/fonts.json"].texts = {}; }, "[ja] ui/simple/fonts.json: text node S/Text has no binding in texts");
-  failsWith((p) => { withHost(p); delete p.groups.ja["ui/simple/fonts/font_Test ja_0.png"]; }, "[ja] ui/simple/fonts.json: textures.font_Test ja_0: ui/simple/fonts/font_Test ja_0.png not in the language group");
-});
-
-test("chat window texts: a binding per text with open fonts, none with game fonts", () => {
-  assert.equal(validate(withChat).status, 0, validate(withChat).lines.join("\n"));
-  assert.deepEqual(schema("story-fonts")(buildSiteFonts(withChat)), []);
-  failsWith((p) => { withChat(p); delete p.groups.ja["ui/fonts.json"].chatTexts.Line["Line/Top/Name"]; }, "[ja] ui/fonts.json: chat window Line: text Line/Top/Name has no binding in chatTexts");
-  failsWith((p) => { withChat(p); p.groups.en["ui/fonts.json"].chatTexts.Line["Line/Top/Name"].localized.fontAsset = "Gone SDF"; }, "chatTexts.Line.Line/Top/Name: font asset Gone SDF not in fonts");
-  failsWith((p) => { withChat(p); p.groups.en["ui/fonts.json"].chatTexts.Other = { "O/T": p.groups.en["ui/fonts.json"].texts["W/Talk"] }; }, "chatTexts.Other.O/T: not a text of ui/ui.json chatTexts");
-  const game = (p) => {
-    withChat(p);
-    p.man.fonts = "game";
-    for (const lang of ["ja", "en"]) { p.groups[lang]["ui/fonts.json"].source = "game"; p.groups[lang]["ui/languages.json"].fonts = "game"; }
-  };
-  failsWith(game, "[ja] ui/fonts.json: chatTexts in game-font data");
-  assert.equal(validate((p) => { game(p); for (const lang of ["ja", "en"]) delete p.groups[lang]["ui/fonts.json"].chatTexts; }).status, 0);
-});
-
-test("dialog texts: a binding per text node of ui.json dialogs", () => {
-  const r = validate(withDialog);
-  assert.equal(r.status, 0, r.lines.join(" | "));
-  failsWith((p) => { withDialog(p); delete p.groups.en["ui/fonts.json"].dialogTexts; }, "[en] ui/fonts.json: dialog Skip: text Skip/Message has no binding in dialogTexts");
-  failsWith((p) => { withDialog(p); p.groups.ja["ui/fonts.json"].dialogTexts.Skip["Skip/Other"] = p.groups.ja["ui/fonts.json"].texts["W/Talk"]; }, "dialogTexts.Skip.Skip/Other: not a text of ui/ui.json dialogs");
-});
-
-test("frame texts: a binding per text node of the frames with open fonts, none with game fonts", () => {
-  const r = validate(withFrames);
-  assert.equal(r.status, 0, r.lines.join(" | "));
-  assert.deepEqual(schema("story-fonts")(buildSiteFonts(withFrames)), []);
-  failsWith((p) => { withFrames(p); delete p.groups.ja["ui/fonts.json"].frameTexts; }, "[ja] ui/fonts.json: frame Comment: text Comment/Body has no binding in frameTexts");
-  failsWith((p) => { withFrames(p); p.groups.en["ui/fonts.json"].frameTexts.Plain = { "Plain": p.groups.en["ui/fonts.json"].texts["W/Talk"] }; }, "[en] ui/fonts.json: frameTexts.Plain.Plain: not a text of frames.json frames");
-  failsWith((p) => { withFrames(p); p.groups.en["ui/fonts.json"].frameTexts.Comment["Comment/Body"].localized.fontAsset = "Gone SDF"; }, "frameTexts.Comment.Comment/Body: font asset Gone SDF not in fonts");
-  failsWith((p) => { withFrames(p); p.common["story.json"].frames = null; delete p.common["frames.json"]; }, "frameTexts.Comment.Comment/Body: not a text of frames.json frames");
-  const game = (p) => {
-    withFrames(p);
-    p.man.fonts = "game";
-    for (const lang of ["ja", "en"]) { p.groups[lang]["ui/fonts.json"].source = "game"; p.groups[lang]["ui/languages.json"].fonts = "game"; }
-  };
-  failsWith(game, "[ja] ui/fonts.json: frameTexts in game-font data");
-  assert.equal(validate((p) => { game(p); for (const lang of ["ja", "en"]) delete p.groups[lang]["ui/fonts.json"].frameTexts; }).status, 0);
-});
-
-test("missing glyph: characters the font assets lack, drawn as a character the asset holds", () => {
-  const r = validate(withMissingGlyph);
-  assert.equal(r.status, 0, r.lines.join(" | "));
-  const doc = buildSiteFonts(withMissingGlyph);
-  assert.deepEqual(schema("story-fonts")(doc), []);
-  const a = doc.fonts["Test SDF"];
-  assert.ok(schema("story-fonts")({ ...doc, fonts: { "Test SDF": { ...a, missingGlyph: { ...a.missingGlyph, extra: 1 } } } }).some((e) => e.includes("missingGlyph")));
-  assert.ok(schema("story-fonts")({ ...doc, fonts: { "Test SDF": { ...a, missingGlyph: { unicode: SQUARE, characters: [] } } } }).some((e) => e.includes("missingGlyph/characters")));
-  const edit = (fn) => (p) => { withMissingGlyph(p); fn(p.groups.ja["ui/fonts.json"]); };
-  failsWith(edit((f) => { f.fonts["Test SDF"].missingGlyph.characters = [0x48, HEART, VS16]; f.coverage.missingGlyph.unshift("H"); }),
-    "[ja] ui/fonts.json fonts.Test SDF: missingGlyph.characters U+0048 held by the asset or its fallbacks");
-  failsWith(edit((f) => { delete f.fonts["Test SDF"].characters[SQUARE]; }), "missingGlyph.unicode U+25A1 held by neither the asset nor its fallbacks");
-  failsWith(edit((f) => { f.fonts["Test SDF"].missingGlyph.characters.reverse(); }), "missingGlyph.characters not ascending");
-  failsWith(edit((f) => { delete f.coverage.missingGlyph; }), "coverage.missingGlyph [], the font assets' missingGlyph characters U+2661 U+FE0F");
-  // U+0003: synthesized, no asset holds it
-  assert.equal(validate(edit((f) => { f.fonts["Test SDF"].missingGlyph.unicode = 3; delete f.fonts["Test SDF"].characters[SQUARE]; })).status, 0);
-  // with the game's TMP settings: the first of the settings' character (0: U+25A1), U+0020, U+0003 the asset holds
-  const settings = (unicode, ch = 0) => edit((f) => { f.tmpSettings = { m_missingGlyphCharacter: ch }; f.fonts["Test SDF"].missingGlyph.unicode = unicode; });
-  assert.equal(validate(settings(SQUARE)).status, 0);
-  failsWith(settings(0x20), "missingGlyph.unicode U+0020, TextMeshPro draws U+25A1");
-  failsWith(settings(SQUARE, 0x20), "missingGlyph.unicode U+25A1, TextMeshPro draws U+0020");
-});
-
-test("sprite assets: the emoji sprite asset, its material, glyphs and pages, the texts that draw it", () => {
-  const r = validate(withSprites);
-  assert.equal(r.status, 0, r.lines.join(" | "));
-  const doc = buildSiteFonts(withSprites);
-  assert.deepEqual(schema("story-fonts")(doc), []);
-  const sa = doc.spriteAssets.Emoji;
-  assert.ok(schema("story-fonts")({ ...doc, spriteAssets: { Emoji: { ...sa, sequences: [{ name: "1f600", unicode: 0 }] } } }).some((e) => e.includes("sequences/0/name")));
-  assert.ok(schema("story-fonts")({ ...doc, spriteAssets: { Emoji: { ...sa, material: undefined } } }).some((e) => e.includes("material")));
-  const edit = (fn) => (p) => { withSprites(p); fn(p.groups.en["ui/fonts.json"]); };
-  const E = "[en] ui/fonts.json";
-  failsWith(edit((f) => { f.texts["W/Talk"].spriteAsset = "Nope"; }), `${E}: texts.W/Talk: sprite asset Nope not in spriteAssets`);
-  failsWith(edit((f) => { f.spriteAssets.Other = f.spriteAssets.Emoji; f.texts["W/Talk"].spriteAsset = "Other"; f.coverage.sprites.characters = 4; }),
-    `${E}: texts.W/Talk: sprite asset Other, emojiSpriteAsset Emoji`);
-  failsWith(edit((f) => { delete f.texts["W/Talk"].m_tintAllSprites; }), `${E}: texts.W/Talk: a sprite asset without m_tintAllSprites`);
-  failsWith(edit((f) => { f.emojiSpriteAsset = "Other"; }), `${E}: emojiSpriteAsset Other not in spriteAssets`);
-  failsWith(edit((f) => { f.materials["Emoji Material"].shader.shader = TMP; }), `${E} spriteAssets.Emoji: material Emoji Material: shader ${TMP}, not ${SPRITE}`);
-  failsWith(edit((f) => { f.spriteAssets.Emoji.characters[0].glyph = 9; }), `${E} spriteAssets.Emoji: character 1f600: glyph 9 not in glyphs`);
-  failsWith(edit((f) => { f.spriteAssets.Emoji.characters.reverse(); }), `${E} spriteAssets.Emoji: characters not in the order of their index`);
-  failsWith(edit((f) => { f.spriteAssets.Emoji.glyphs[0].rect.m_X = 6; }), `${E} spriteAssets.Emoji: glyph 0: rect + offset leaves page sprite_Emoji (8x8)`);
-  failsWith(edit((f) => { f.spriteAssets.Emoji.glyphs[1].rect.m_Width = 2; f.spriteAssets.Emoji.glyphs[1].rect.m_Height = 2; }), `${E} spriteAssets.Emoji: glyph 1: a rect without packed texels`);
-  failsWith(edit((f) => { f.coverage.sprites.characters = 3; }), `${E}: coverage.sprites.characters 3, the sprite assets hold 2`);
-  failsWith(edit((f) => { f.coverage.sprites.missing = ["1f600"]; }), `${E}: coverage.sprites.missing: 1f600 has an image`);
-  failsWith(edit((f) => { f.coverage.sprites.missing = ["263a"]; }), `${E}: coverage.sprites.missing: 263a is not a sprite character`);
-  failsWith(edit((f) => { delete f.coverage.sprites; }), `${E}: spriteAssets without coverage.sprites`);
-  const bare = (f) => { delete f.spriteAssets; delete f.emojiSpriteAsset; delete f.coverage.sprites; };
-  failsWith(edit((f) => { bare(f); }), `${E}: W/Talk: a sprite asset without spriteAssets`);
-  failsWith(edit((f) => { bare(f); delete f.texts["W/Talk"].spriteAsset; f.emojiSpriteAsset = "Emoji"; }), `${E}: emojiSpriteAsset without spriteAssets`);
-});
-
-test("fallback font assets: the fallback material of each text material (GetFallbackMaterial)", () => {
-  const r = validate(withFallback);
-  assert.equal(r.status, 0, r.lines.join(" | "));
-  assert.deepEqual(schema("story-fonts")(buildSiteFonts(withFallback)), []);
-  const edit = (fn) => (p) => { withFallback(p); fn(p.groups.ja["ui/fonts.json"]); };
-  const M = "Test - Outline + Fb SDF", E = "[ja] ui/fonts.json";
-  failsWith(edit((f) => { delete f.materials[M]; delete f.materialKeywords[M]; }),
-    `${E}: material ${M} (fallback Fb SDF of Test SDF) not in materials`);
-  failsWith(edit((f) => { f.materials[M].floats._GradientScale = 5; }), `${E}: material ${M}: _GradientScale, _ScaleRatioA, _ScaleRatioC not as GetFallbackMaterial(Test - Outline, Fb SDF Material)`);
-  failsWith(edit((f) => { f.materials[M].floats._ScaleRatioA = 0.8; }), `material ${M}: _ScaleRatioA not as`);
-  failsWith(edit((f) => { f.materials[M].floats._OutlineWidth = 0.3; f.materials[M].floats._ScaleRatioA = Math.fround(15 / 16); }),
-    `material ${M}: _OutlineWidth not as`);
-  failsWith(edit((f) => { f.materials[M].textures._MainTex.texture.name = "font_Test ja_0"; }), `material ${M}: _MainTex not as`);
-  failsWith(edit((f) => { f.materials[M].keywords = []; }), `material ${M}: shader / keywords not as`);
-  failsWith(edit((f) => { f.fonts["Test SDF"].fallbacks.push("Test SDF"); }), `${E} fonts.Test SDF: fallbacks list the asset itself or an asset twice`);
-});
-
-// ------------------------------------------------------------------------------------------------ models
-// a Live2D model m1 used by a Character row: its files in models/m1.json, story.json naming it, the story's shaders
-const ADDRESS = "Character/Live2D/g/m1/model/m1";
-const withModel = (p, opts = {}) => {
-  p.models.m1 = modelObjects("m1", opts);
-  p.common["story.json"].models = { [ADDRESS]: "m1" };
-  const ep = p.common["episode.json"];
-  ep.commands.push({ i: 3, cmd: "Character", raw: 1, TargetName: "a", TargetAssetName: "g/m1/model/m1" });
-  ep.commandCount = ep.commands.length;
-  p.man.story.commandCount = ep.commands.length;
-  p.man.story.commands = p.man.requires.commands = [...p.man.story.commands, "Character"].sort();
-  Object.assign(p.common, shaderFiles("shaders", ["Adv/AlphaBlend"]));
-};
-
-const expectLine = (r, text) => {
-  assert.equal(r.status, 1, r.lines.join("\n"));
-  assert.ok(r.lines.some((l) => l.includes(text)), `"${text}" in:\n${r.lines.join("\n")}`);
-};
-
-test("models: the manifest's model manifests, valid as models; live2d/ holds their files alone", () => {
-  const ok = validate(withModel);
-  assert.equal(ok.status, 0, ok.lines.join("\n") + ok.stderr);
-  assert.deepEqual(ok.lines, ["1/1 models valid", "1/1 stories valid"]);
-  assert.equal(validate((p) => { withModel(p); p.modelsIndex = true; }).status, 0);
-  assert.equal(validate((p) => { withModel(p); p.index = false; }).status, 0);
-  assert.equal(validate((p) => { withModel(p, { masked: false, motionSync: true }); }).status, 0);
-  // the manifest's models and story.json's
-  failsWith((p) => { withModel(p); p.man.models = {}; p.index = false; }, `story.json: models.${ADDRESS}: model m1 is not in the manifest's models`);
-  failsWith((p) => { withModel(p); p.common["story.json"].models = {}; }, "manifest: models.m1: no model address of story.json names it");
-  failsWith((p) => { withModel(p); p.common["story.json"].models = {}; }, `episode.json: row 3: model ${ADDRESS} is not in story.json models`);
-  failsWith((p) => { withModel(p); p.man.models = { m1: "models/other.json" }; p.index = false; }, "manifest: models.m1: models/other.json, expected models/m1.json");
-  failsWith((p) => {
-    withModel(p);
-    p.man.models = { m1: "models/m1.json", m2: "models/m2.json" };
-    p.index = false;
-    p.common["story.json"].models["Character/Live2D/g/m2/model/m2"] = "m2";
-  }, "manifest: models.m2: models/m2.json missing");
-  failsWith((p) => {
-    withModel(p);
-    p.models.m0 = modelObjects("m0");
-    p.man.models = { m1: "models/m1.json", m0: "models/m0.json" };
-    p.common["story.json"].models["Character/Live2D/g/m0/model/m0"] = "m0";
-  }, "manifest: models: keys not sorted");
-  failsWith((p) => { withModel(p); p.modelsIndex = []; }, "manifest: models.m1: not in models.json");
-  failsWith((p) => { withModel(p); p.index = (e) => { e.size.models += 1; }; }, "stories.json: size");
-  // no story file under live2d/
-  failsWith((p) => { withModel(p); p.common["live2d/m1/model.json"] = {}; }, "manifest: files: live2d/m1/model.json: live2d/ holds the files of the models");
-  failsWith((p) => { withModel(p); p.groups.en["live2d/m1/x.json"] = {}; }, "manifest: languages.en: live2d/m1/x.json: live2d/ holds");
-  // a model manifest that is not a valid model fails the model and the story
-  const bad = validate((p) => { withModel(p); p.models.m1.objects.mono("CubismFadeMotionData", "extra"); });
-  assert.equal(bad.status, 1);
-  assert.ok(bad.lines.includes("FAIL m1") && bad.lines.includes("FAIL 7"), bad.lines.join("\n"));
-  assert.ok(bad.lines.some((l) => /^models\/m1\.json: not a valid model \(1 problem\): CAB-m1:\d+#json: listed but read by neither/.test(l)),
-            bad.lines.join("\n"));
-  failsWith((p) => { withModel(p); p.models.m1.model.motionSync = true; },
-            "model.json: motionSync true, the prefab's root has no MotionSync controller with a CRI audio input");
-});
-
-test("root: the site root seen from the manifest, ../../ for a region's own", () => {
-  const r = validate((p) => { withModel(p); p.where = "stories/tw/7.json"; p.man.root = "../../"; });
-  assert.equal(r.status, 0, r.lines.join("\n") + r.stderr);
-  failsWith((p) => { withModel(p); p.where = "stories/tw/7.json"; }, 'manifest: root "../", the site root from stories/tw/7.json is "../../"');
-  failsWith((p) => { p.man.root = "../../"; }, 'manifest: root "../../", the site root from stories/7.json is "../"');
-});
-
-test("models: the programs the story renderer draws with at every quality", () => {
-  // a model without the Lit programs of quality 4 is not a valid model, and its stories fail
-  const r = validate((p) => withModel(p, { storyLights: false }));
-  assert.equal(r.status, 1);
-  assert.ok(r.lines.includes("FAIL m1") && r.lines.includes("0/1 models valid") && r.lines.includes("0/1 stories valid"), r.lines.join("\n"));
-  const lit = "Live2D Cubism/Lit-URP-ADV-optimize";
-  assert.ok(r.lines.includes(`shader ${lit}: ${lit}: no variant for [_ADDITIONAL_LIGHTS_VERTEX] (the story renderer's keywords at quality 4)`),
-            r.lines.join("\n"));
-  assert.ok(r.lines.some((l) => l.includes("no variant for [CUBISM_MASK_ON _ADDITIONAL_LIGHTS_VERTEX]")), r.lines.join("\n"));
-});
-
-test("encoded assets: gzip and brotli, decoded and checked against their name, size and stored length", () => {
+test("emoji assets, glyphs, materials and text references are checked", () => {
+  passes(withSprites);
+  const edit = fn => f => { withSprites(f); fn(f.fonts.ja, f); };
+  fails(edit((d, f) => { d.sprites[f.textId].spriteAsset = "Absent"; }), /not the emoji sprite asset/);
+  fails(edit(d => { d.spriteAssets.Emoji.material = "Absent"; }), /material Absent not in materials/);
+  fails(edit(d => { d.spriteAssets.Emoji.characters[0].glyph = 1; }), /glyph 1 missing/);
+  fails(edit(d => { d.coverage.sprites.characters = 2; }), /coverage.sprites.characters differs/);
+  fails(edit(d => { d.coverage.sprites.missing = ["1f600"]; }), /not a missing sprite/);
+});
+
+test("all text sources share component-id font bindings", () => {
+  for (const source of ["dialog", "chat", "frame"]) passes(f => {
+    const id = f.o.prefab([{ path: source, name: source, localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 }, active: true,
+      components: [{ type: "MonoBehaviour", pathId: "1001", script: "Test||TextMeshProUGUI", fields: {} }] }]);
+    const doc = JSON.parse(f.o.objects[id].files.json); doc.nodes[0].components[0].pathId = "1001"; f.o.objects[id].files.json = JSON.stringify(doc);
+    for (const [lang, d] of Object.entries(f.fonts)) {
+      d.texts["fixture:1001"] = structuredClone(d.texts[f.textId]);
+      f.ui[lang].texts["fixture:1001"] = structuredClone(f.ui[lang].texts[f.textId]);
+      if (source === "dialog") f.ui[lang].dialogs.Dialog = id;
+    }
+    if (source !== "dialog") { const key = source === "chat" ? "Adv/ChatWindow/chat" : "Adv/Frame/frame";
+      f.story.parts.assets[key] = `storyassets/${source}.json`; f.add(`storyassets/${source}.json`, "story.asset", key, { "asset.json": { format: 1, key, objects: [id], bindings: {}, shaders: {} } }); }
+  });
+});
+
+const withOverlay = f => {
+  f.episode.master._playbackMode = 1; f.story.host = { kind: "afterlive" };
+  const r = { prefab: f.prefab, path: "Widget" };
+  f.story.parts.host = { afterlive: "storyhosts/afterlive.json" };
+  f.add("storyhosts/afterlive.json", "story.host", "afterlive", { "host.json": { format: "nnnotes.story-host/1", kind: "afterlive",
+    cameraTarget: f.prefab, dotween: f.ui.ja.settings.dotween, prefabs: {}, overlayRoot: r, layoutRoot: { ...r, fields: {} }, openedSequences: [], home: null,
+    afterlive: { rewardPanel: r, backgroundImage: r, backgroundSprite: f.sprite }, graphics: { graphics: f.graphics }, bindings: {}, shaders: {} } });
+  f.story.parts.simpleui = {};
+  for (const lang of Object.keys(f.fonts)) { const u = f.ui[lang], file = `storysimpleui/${lang}.json`; f.story.parts.simpleui[lang] = file;
+    f.add(file, "story.simpleui", lang, { "ui.json": { format: "nnnotes.story-simple-ui/1", language: u.language, settings: u.settings,
+      graphics: u.graphics, texts: u.texts, textStyle: {}, bindings: {}, shaders: {}, talkWindow: f.prefab, systemMessage: f.prefab, uiManager: f.prefab } }); }
+};
+test("Overlay products reference their host nodes and simple UI", () => {
+  passes(withOverlay);
+  fails(f => { withOverlay(f); delete f.story.parts.simpleui; }, /requires parts.simpleui/);
+  fails(f => { withOverlay(f); f.products.get("storyhosts/afterlive.json").files["host.json"].overlayRoot = { prefab: f.prefab, path: "Gone" }; }, /node Gone not in/);
+  fails(f => { withOverlay(f); f.story.host.kind = "home"; }, /kind differs from the episode host/);
+});
+
+test("CRI Lips weights match their typed descriptor and block bounds", () => {
+  const add = f => { f.story.parts.crilips = "crilips/default.json"; f.add(f.story.parts.crilips, "story.crilips", "default", {
+    "crilips.json": { dtype: "float32", order: "LE", total_floats: 2, constants: {}, frontend: {}, blocks: [{ name: "weights", offset: 0, count: 2 }] }, "crilips.bin": Buffer.alloc(8) }); };
+  passes(add);
+  fails(f => { add(f); f.products.get(f.story.parts.crilips).files["crilips.json"].blocks[0].count = 3; }, /outside weights/);
+  fails(f => { add(f); f.products.get(f.story.parts.crilips).files["crilips.json"].total_floats = 3; }, /differs from total_floats/);
+});
+
+test("model dependencies are validated and Character rows must name them", () => {
+  passes(f => { f.modelOptions = {}; });
+  fails(f => { f.episode.commands.push({ i: 2, cmd: "Character", raw: ADV_COMMAND.indexOf("Character"), TargetAssetName: "g/m/model/m" }); f.episode.commandCount++; }, /not in parts.models/);
+  fails(f => { f.modelOptions = { storyLights: false }; }, /no variant|story renderer|_ADDITIONAL_LIGHTS_VERTEX/);
+  fails(f => { f.modelOptions = {}; }, /expected live2d.model product/, (dir) => {
+    const file = path.join(dir, "models/m1.json"), m = JSON.parse(fs.readFileSync(file, "utf8")); m.subject = "wrong"; fs.writeFileSync(file, JSON.stringify(m));
+  });
+});
+
+test("assets are present and checked against their byte counts and content names", () => {
+  fails(undefined, /missing|ENOENT/, (dir, manifests) => { fs.unlinkSync(path.join(dir, manifests.get("stories/7.json").files["episode.json"].asset)); });
+  fails(undefined, /bytes|size/, (dir, manifests) => { const m = manifests.get("stories/7.json"); m.files["episode.json"].size++; fs.writeFileSync(path.join(dir, "stories/7.json"), JSON.stringify(m)); });
+  fails(undefined, /SHA|hash|name/, (dir, manifests) => { const file = path.join(dir, manifests.get("stories/7.json").files["episode.json"].asset); const b = fs.readFileSync(file); b[1] ^= 1; fs.writeFileSync(file, b); });
+});
+
+test("gzip and brotli product files retain decoded and stored byte checks", () => {
   for (const encoding of ["gzip", "br"]) {
-    const { dir, man } = buildSite((p) => { withModel(p); p.encoding = encoding; });
-    fs.rmSync(dir, { recursive: true, force: true });
-    const ext = encoding === "gzip" ? ".gz" : ".br";
-    assert.ok(Object.values(man.files).some((f) => f.asset && f.asset.endsWith(`.json${ext}`) && f.stored < f.size));
-    assert.ok(!Object.values(man.files).some((f) => /\.(png|flac)\.(gz|br)$/.test(f.asset || "")));
-    assert.deepEqual(schema("story-manifest")(man), []);
-    const r = validate((p) => { withModel(p); p.encoding = encoding; });
-    assert.equal(r.status, 0, r.lines.join("\n") + r.stderr);
-    assert.deepEqual(r.lines, ["1/1 models valid", "1/1 stories valid"]);
+    passes(f => { f.encoding = encoding; });
+    fails(f => { f.encoding = encoding; }, /stored/, (dir, manifests) => { const m = manifests.get("stories/7.json"); m.files["episode.json"].stored++; fs.writeFileSync(path.join(dir, "stories/7.json"), JSON.stringify(m)); });
   }
-  const gz = (p) => { withModel(p); p.encoding = "gzip"; };
-  const rewrite = (dir, man) => fs.writeFileSync(path.join(dir, "stories", "7.json"), JSON.stringify(man));
-  const epi = (man) => man.files["episode.json"];
-  // the stored length is the file's
-  expectLine(validateBuilt(gz, (dir, man) => { epi(man).stored += 1; rewrite(dir, man); }), "bytes, manifest stored");
-  // the bytes are gzip data that decodes to the named content of `size` bytes
-  expectLine(validateBuilt(gz, (dir, man) => { fs.writeFileSync(path.join(dir, epi(man).asset), Buffer.alloc(epi(man).stored, 7)); }),
-             "not gzip data");
-  expectLine(validateBuilt(gz, (dir, man) => {
-    const f = epi(man), other = encode(Buffer.alloc(f.size, 0x20), "gzip");
-    fs.writeFileSync(path.join(dir, f.asset), other); f.stored = other.length; rewrite(dir, man);
-  }), "content SHA-256 is");
-  expectLine(validateBuilt(gz, (dir, man) => {
-    const f = epi(man), other = encode(Buffer.alloc(f.size + 1, 0x20), "gzip");
-    fs.writeFileSync(path.join(dir, f.asset), other); f.stored = other.length; rewrite(dir, man);
-  }), "bytes decoded, manifest");
-  // stored exactly on encoded assets, less than size, of a compressible extension
-  expectLine(validateBuilt(undefined, (dir, man) => { epi(man).stored = epi(man).size - 1; rewrite(dir, man); }),
-             "on an asset that is not encoded");
-  expectLine(validateBuilt(undefined, (dir, man) => {
-    const text = Buffer.from("{}"), z = encode(text, "gzip"), asset = `assets/${sha256(text)}.json.gz`;
-    fs.writeFileSync(path.join(dir, asset), z);
-    man.files["extra.json"] = { asset, size: text.length, stored: z.length }; rewrite(dir, man);
-  }), "is not less than size 2");
-  expectLine(validateBuilt(undefined, (dir, man) => {
-    const b = Buffer.concat([fs.readFileSync(path.join(dir, man.files["ui/textures/sprites.png"].asset)), Buffer.alloc(4096)]);
-    const z = encode(b, "gzip"), asset = `assets/${sha256(b)}.png.gz`;
-    fs.writeFileSync(path.join(dir, asset), z);
-    man.files["ui/textures/big.png"] = { asset, size: b.length, stored: z.length }; rewrite(dir, man);
-  }), ".png files are stored as they are, not encoded");
-  expectLine(validateBuilt(undefined, (dir, man) => {
-    const f = epi(man), z = encode(fs.readFileSync(path.join(dir, f.asset)), "gzip");
-    fs.writeFileSync(path.join(dir, `${f.asset}.gz`), z);
-    man.files["episode.json"] = { asset: `${f.asset}.gz`, size: f.size }; rewrite(dir, man);
-  }), "an encoded asset without stored");
 });
 
-test("the schemas: stored exactly with a .gz / .br asset, parts of four items, manifest root and models, story.json models", () => {
-  const S = schema("story-manifest"), { dir, man } = buildSite(withModel);
-  const story = JSON.parse(fs.readFileSync(path.join(dir, man.files["story.json"].asset), "utf8"));
-  fs.rmSync(dir, { recursive: true, force: true });
-  const a = "a".repeat(64), withFiles = (files) => ({ ...man, files });
-  assert.deepEqual(S(man), []);
-  assert.deepEqual(S(withFiles({ "x.json": { asset: `assets/${a}.json.gz`, size: 10, stored: 5 },
-                                 "y.moc3": { asset: `assets/${a}.moc3.br`, size: 10, stored: 5 },
-                                 "z.json": { parts: [["k", `assets/${a}.json`, 3], ["l", `assets/${a}.json.gz`, 30, 20]], size: 40 } })), []);
-  for (const bad of [{ "x.json": { asset: `assets/${a}.json.gz`, size: 10 } },
-                     { "x.json": { asset: `assets/${a}.json`, size: 10, stored: 5 } },
-                     { "x.json": { asset: `assets/${a}.json.zst`, size: 10, stored: 5 } },
-                     { "z.json": { parts: [["k", `assets/${a}.json`, 3, 2]], size: 3 } },
-                     { "z.json": { parts: [["k", `assets/${a}.json.gz`, 3]], size: 3 } }])
-    assert.ok(S(withFiles(bad)).length > 0, JSON.stringify(bad));
-  assert.ok(S({ ...man, root: "./" }).some((e) => e.includes("/root")));
-  assert.ok(S({ ...man, models: { m1: "live2d/m1.json" } }).some((e) => e.includes("/models/m1")));
-  const { root, models, ...rest } = man;
-  assert.equal(root, "../");
-  assert.ok(S({ ...rest, models }).length > 0);                            // a manifest needs root and models
-  assert.ok(S({ ...rest, root }).length > 0);
-  assert.ok(S({ ...man, format: "ournotes.story-manifest/1" }).some((e) => e.includes("/format")));
-  assert.deepEqual(schema("story")(story), []);
-  assert.deepEqual(schema("story")({ ...story, modelsDir: "../live2d" }), []);
-  assert.ok(schema("story")({ ...story, models: { [ADDRESS]: { dir: "live2d/m1", moc3: "m1.moc3", prefab: "m1.prefab.json" } } })
-    .some((e) => e.includes("/models/")));
+test("regional story manifests resolve from their explicit site root", () => {
+  passes(f => { f.where = "stories/tw/7.json"; f.manifest.root = "../../"; });
+  fails(f => { f.where = "stories/tw/7.json"; }, /expected \.\.\/\.\.\//);
 });
diff --git a/tests/unit/story-screen-resources.mjs b/tests/unit/story-screen-resources.mjs
new file mode 100644
index 0000000..a4176a3
--- /dev/null
+++ b/tests/unit/story-screen-resources.mjs
@@ -0,0 +1,92 @@
+import { AnimClip, AnimController } from "../../src/engine/anim.js";
+import { Prefab } from "../../src/engine/prefab.js";
+
+let componentId = 1;
+export const nativeComponent = ({ type = "MonoBehaviour", class: cls, ...fields }) => fields.fields
+  ? { type, ...fields } : { type, pathId: String(componentId++), ...(cls ? { script: `Test||${cls}` } : {}), fields };
+
+// Resource doubles shared by the screen's behavioral tests. Each product owns a separate prefab.
+export const screenResources = (ctx, widget, products = {}) => {
+  const materials = new Map(), sprites = new Map(), prefabs = new Map();
+  const paths = (v) => {
+    if (typeof v === "string" && v.startsWith("UIAdvWidget/")) return { gameObject: v };
+    if (Array.isArray(v)) return v.map(paths);
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, paths(x)]));
+    return v;
+  };
+  const node = (path, components = []) => ({ path, name: path.split("/").at(-1), active: true,
+    localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 }, localScale: { x: 1, y: 1, z: 1 }, components });
+  const nodes = widget.nodes.map((n) => {
+    const cs = [];
+    const add = (cls, fields) => { if (fields) cs.push(nativeComponent({ ...fields, class: cls })); };
+    if (n.canvas) add("Canvas", { ...n.canvas, m_Camera: n.canvas.camera ? { gameObject: n.canvas.camera } : null });
+    add(n.canvasScaler?.class || "CanvasScaler", n.canvasScaler);
+    add("CanvasGroup", n.canvasGroup);
+    if (n.image) add("Image", { ...n.image, m_Sprite: n.image.sprite ? widget.sprites[n.image.sprite] : null,
+      m_Material: n.image.material ? widget.materials[n.image.material] : null });
+    if (n.rawImage) add("RawImage", { ...n.rawImage, m_Material: n.rawImage.material });
+    add("AdvStillView", paths(n.stillView)); add("AdvVideoView", paths(n.videoView));
+    return { ...n, components: cs };
+  });
+  nodes.unshift(node("UIAdvWidget", [nativeComponent({ class: "UIAdvWidget",
+    _videoAndStillCamera: { gameObject: widget.videoAndStillCamera.path },
+    _videoAndStillScreenImage: { gameObject: widget.videoAndStillScreenImage } })]));
+  const cam = widget.videoAndStillCamera;
+  nodes.push(node(cam.path, [nativeComponent({ type: "Camera", ...cam.camera }),
+    nativeComponent({ class: "UniversalAdditionalCameraData", ...cam.additionalCameraData })]));
+  for (const n of widget.nodes) {
+    const path = n.canvas?.camera;
+    if (path && !nodes.some((r) => r.path === path)) nodes.push(node(path));
+  }
+  const docs = { "fixture:widget": { key: "widget", nodes } };
+  const manager = [node("UIManager")];
+  if (widget.uiCamera) manager.push(node("UIManager/UICamera", [nativeComponent({ type: "Camera", ...widget.uiCamera.camera })]));
+  docs["fixture:manager"] = { key: "manager", nodes: manager };
+  for (const [key, doc] of Object.entries(products))
+    docs[`fixture:${key}`] = { ...doc, nodes: doc.nodes.map((n) => ({ ...n, components: n.components.map(nativeComponent) })) };
+  const objects = {
+    prefab: (id) => {
+      if (!prefabs.has(id)) { const p = new Prefab(docs[id]); p.ids = [id]; prefabs.set(id, p); }
+      return prefabs.get(id);
+    },
+    id: (v) => v,
+    sprite: (s) => {
+      if (!s) return null;
+      if (!sprites.has(s)) {
+        const tex = typeof s.texture === "string" ? widget.textures[s.texture] : s.texture;
+        sprites.set(s, { ...s, id: s.sprite || s.name || "sprite", name: s.sprite || s.name,
+          texture: { ...tex, id: tex.texture, wrapU: tex.settings?.m_WrapU ?? 1, wrapV: tex.settings?.m_WrapV ?? 1 } });
+      }
+      return sprites.get(s);
+    },
+    material: (m) => {
+      if (!m) return null;
+      if (!materials.has(m)) materials.set(m, { ...m, id: m.material, shader: m.shader.shader,
+        textures: Object.fromEntries(Object.entries(m.textures || {}).map(([k, t]) => [k,
+          { ...t, texture: t.texture ? { ...t.texture, id: t.texture.texture } : null }])) });
+      return materials.get(m);
+    },
+    mesh: (m) => m,
+    controller: (raw) => {
+      if (!raw) return null;
+      const clips = new Map();
+      const visit = (v) => {
+        if (!v || typeof v !== "object") return;
+        if (v.clip && v.bindings) clips.set(v.clip, v);
+        for (const x of Object.values(v)) visit(x);
+      };
+      visit(products);
+      return AnimController.fromMecanim(raw, (c) => AnimClip.fromMecanim(clips.get(c.clip), c.clip));
+    },
+  };
+  const previous = ctx.data;
+  ctx.data = { ...previous, ui: { widget: "fixture:widget", uiManager: "fixture:manager" },
+    asset: (address) => {
+      const key = `fixture:${address.replace(/^Adv\/(Frame|Still)\//, "")}`;
+      if (!docs[key]) throw new Error(`${address}: not in the story data`);
+      return { objects: [key] };
+    } };
+  ctx.assets = { ...ctx.assets, prefab: (id) => docs[id] };
+  ctx.objects = objects;
+  return objects;
+};
diff --git a/tests/unit/story-simple-home.test.mjs b/tests/unit/story-simple-home.test.mjs
index 672fb63..7b281b8 100644
--- a/tests/unit/story-simple-home.test.mjs
+++ b/tests/unit/story-simple-home.test.mjs
@@ -12,15 +12,23 @@ import { forwardOf, lookRotation, rotateVector, slerp, SpotCamera, spotFieldOfVi
 import { parseGlb, roomMeshes } from "../../src/story/simple/home/glb.js";
 import { backgroundMatrix, inverseTRS, NO_TAP_TARGET, roomInverse, roomMatrix, SimpleHomeHost, SPINE_MISSING,
          spotLighting } from "../../src/story/simple/home/host.js";
-import { checkSpotCamera, checkSpotStack, HOME_VIEW_MASK, spotMainCamera, spotVolumeStack,
-         spotVolumes } from "../../src/story/simple/home/post.js";
+import { checkSpotCamera, checkSpotStack, HOME_VIEW_MASK, spotMainCamera, spotVolumeStack as nativeVolumeStack,
+         } from "../../src/story/simple/home/post.js";
 import { URPPost, VOLUME_DEFAULTS } from "../../src/engine/postfx.js";
 import { GLTarget } from "../../src/engine/texture.js";
 import { headlessGL } from "../../scripts/lib/headless.mjs";
 import { mat4 } from "../../src/engine/math.js";
 import { majorMinor, skeletonDataVersion, spineRuntime, spineRuntimeVersion } from "../../src/story/simple/home/spine.js";
+import { homeResources, lightingResources, volumeResources } from "./story-home-resources.mjs";
 import { parseQueueTag, ShaderInfo, sortDrawItems, SpotRoom } from "../../src/story/simple/home/room.js";
 
+const createHome = (gl, store, loop, host, opts = {}) => {
+  const { data, objects } = homeResources(store, host, opts, gl);
+  return SimpleHomeHost.create(gl, store, loop, data, { ...opts, objects });
+};
+const spotVolumes = (h) => [...(h.sceneRoot?.volumes || []), ...(h.volume ? [h.volume] : [])];
+const spotVolumeStack = (h, mask, what) => nativeVolumeStack(spotVolumes(h).map(volumeResources), mask, what);
+
 const F = Math.fround;
 const near = (a, b, eps = 1e-6) => Math.abs(a - b) <= eps;
 const nearVec = (a, b, eps = 1e-6) => ["x", "y", "z"].every((k) => near(a[k], b[k], eps));
@@ -111,7 +119,7 @@ const makeStore = ({ roomNodes, spot = {}, home = {}, meshes } = {}) => {
     spotId: 1, situationSettings: SETTINGS,
     characters: [{ path: "s/A", _characterId: 3, _distanceRatio: 0.3, world: translation(0, 0, 0), focusWorld: translation(1, 0.5, 6) }],
     spineCharacters: [], skeletons: [], ...spot };
-  const hostDoc = { format: "ournotes.story-host/1", kind: "home", home: {
+  const hostDoc = { kind: "home", home: {
     spotId: 1, talk: "tap", characterId: 3, spot: "host/spot/spot.json", room: "host/spot/room.glb", roomNodes: nodes,
     roomMaterials: MATERIALS, situation: { name: "s", matched: true }, sceneRoot: { objRoot: null, lights: [], volumes: [] },
     volume: null, spineMaterials: {}, shaders: { index: "host/shaders/shaders.json", names: Object.keys(SHADERS) },
@@ -125,6 +133,19 @@ const makeStore = ({ roomNodes, spot = {}, home = {}, meshes } = {}) => {
 
 const CAM = { near: 0.3, far: 1000, clearFlags: 2, clearColor: [0, 0, 0, 1] };
 
+test("Spine mesh uploads preserve another renderer's index buffer", () => {
+  const foreign = {}, own = {}, indices = new Map([[foreign, "character indices"]]);
+  let bound = foreign;
+  const gl = { ARRAY_BUFFER: 1, ELEMENT_ARRAY_BUFFER: 2, DYNAMIC_DRAW: 3,
+    bindVertexArray: (vao) => { bound = vao; }, createBuffer: () => ({}),
+    bindBuffer: (target, buffer) => { if (target === 2) indices.set(bound, buffer); }, bufferData() {} };
+  const mesh = { positions: new Float32Array(6), colors: new Uint8Array(8), uvs: new Float32Array(4), indices: new Uint32Array(3) };
+  const skeleton = { skeleton: { buildMesh: () => mesh } };
+  SimpleHomeHost.prototype._uploadSkeleton.call({ gl, vao: own, buffers: [] }, skeleton);
+  assert.equal(indices.get(foreign), "character indices");
+  assert.equal(indices.get(own), skeleton.gpu.index);
+});
+
 // ------------------------------------------------------------------------------------------------------------ glb
 test("glb: the room file's glTF space goes back to Unity space (z, winding, uv v)", () => {
   const bytes = buildGlb([card("a", -4, 0), card("b", -5, 1, { active: false })], [{ name: "m0" }, { name: "m1" }]);
@@ -201,7 +222,7 @@ const tweenPositions = (dt, duration, frames) => {
 test("camera: FocusCharacterAsync and ReturnToDefaultPosition tween 0.5 s InOutQuad on the loop's tween phase", async () => {
   const { store, host } = makeStore();
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(null, store, loop, host, { camera: CAM, spine: null });
+  const h = await createHome(null, store, loop, host, { camera: CAM, spine: null });
   const P = { ...h.camera.position }, R0 = { ...h.camera.rotation };
   const Fw = { x: 1, y: 0.5, z: 6 }, k = F(0.3);
   const target = { x: F(F(F(Fw.x - P.x) * k) + P.x), y: F(F(F(Fw.y - P.y) * k) + P.y), z: F(F(F(Fw.z - P.z) * k) + P.z) };
@@ -287,10 +308,11 @@ test("blur pass: UIRenderPass.Setup clamps, offset = rate x offset, blend = clam
 // -------------------------------------------------------------------------------------------------------------- room
 test("room: roomNodes visibility, the floor queue override and URP's opaque / transparent order", () => {
   const { store, host } = makeStore();
-  const shaders = new ShaderInfo(store, "host/shaders");
+  const { data, objects, summary } = homeResources(store, host, {});
+  const shaders = new ShaderInfo(objects);
   assert.equal(shaders.queue("Unlit/Transparent Cutout"), 2450);
   assert.deepEqual(shaders.forwardPasses("Universal Render Pipeline/Spine/Skeleton"), [0]);
-  const room = new SpotRoom(parseGlb(store.bytes("host/spot/room.glb")), host.home, shaders);
+  const room = new SpotRoom(parseGlb(store.bytes("host/spot/room.glb")), summary, data.host.home.backgroundState, objects, shaders);
   const items = room.drawItems(backgroundMatrix(SETTINGS, null), { x: 0, y: 0, z: 0 });
   assert.deepEqual(items.map((it) => room.meshes[it.part.node].name), ["near", "glass", "floor"]);   // "hidden" is inactive
   const order = sortDrawItems(items.map((it, i) => ({ ...it, index: i }))).map((it) => `${room.meshes[it.part.node].name}:${it.queue}`);
@@ -301,7 +323,7 @@ test("room: roomNodes visibility, the floor queue override and URP's opaque / tr
   assert.deepEqual(sortDrawItems([mk(3000, 9, 0), { ...mk(3000, 1, 1), sortingOrder: 1 }]).map((i) => i.index), [0, 1]);
   assert.equal(parseQueueTag("Transparent+1"), 3001);
   assert.equal(parseQueueTag("Geometry-10"), 1990);
-  assert.throws(() => new SpotRoom(parseGlb(store.bytes("host/spot/room.glb")), { ...host.home, roomNodes: [] }, shaders), /roomNodes/);
+  assert.throws(() => new SpotRoom(parseGlb(store.bytes("host/spot/room.glb")), { ...summary, nodes: [] }, data.host.home.backgroundState, objects, shaders), /room nodes/);
 });
 
 test("background root: localPosition, world eulerAngles and localScale under objRoot", () => {
@@ -334,7 +356,7 @@ test("host: headless create, 'Spine runtime missing' without a runtime or with o
   const { store, host } = makeStore({ spot: spine });
   store._text.set("host/spot/spine/a.json", JSON.stringify({ skeleton: { spine: "4.2.43" } }));
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(null, store, loop, host, { camera: CAM, spine: null });
+  const h = await createHome(null, store, loop, host, { camera: CAM, spine: null });
   assert.deepEqual(h.missing, [SPINE_MISSING]);
   assert.match(h.spineReason, /no Spine runtime/);
   assert.equal(h.skeletons.length, 0);
@@ -349,14 +371,14 @@ test("host: headless create, 'Spine runtime missing' without a runtime or with o
   const old = { TextureAtlas() {}, AtlasAttachmentLoader() {}, SkeletonJson() {}, SkeletonBinary() {}, Skeleton() {}, AnimationState() {},
                 AnimationStateData() {}, Physics: {}, SkeletonClipping() {}, RegionAttachment() {}, MeshAttachment() {}, ClippingAttachment() {},
                 BlendMode: {}, version: "4.1.54" };
-  const h2 = await SimpleHomeHost.create(null, store, loop, host, { camera: CAM, spine: old });
+  const h2 = await createHome(null, store, loop, host, { camera: CAM, spine: old });
   assert.deepEqual(h2.missing, [SPINE_MISSING]);
   assert.match(h2.spineReason, /4\.1 cannot read skeleton data 4\.2\.43/);
   h2.dispose();
   // the spot's volume is drawn by the post chain: nothing listed (no Spine characters in this spot)
   const { store: s3, host: h3doc } = makeStore({ home: { volume: { path: "bg", active: true, enabled: true, isGlobal: true,
     weight: 0.05, priority: 0, blendDistance: 0, layer: 15, profile: "p", components: [] } } });
-  const h3 = await SimpleHomeHost.create(null, s3, loop, h3doc, { camera: CAM, spine: null });
+  const h3 = await createHome(null, s3, loop, h3doc, { camera: CAM, spine: null });
   assert.deepEqual(h3.missing, []);
   h3.dispose();
   assert.throws(() => new SimpleHomeHost(null, store, loop, { kind: "afterlive" }, { camera: CAM }), /not a home host/);
@@ -377,21 +399,21 @@ const GRAPHICS = {
   renderers: { Runtime: { m_RenderingMode: 0, m_RendererFeatures: [{ class: "Fwk.UI.Rendering.UIRendererFeature", m_Active: 1 }] },
                Editor: { m_RenderingMode: 0, m_RendererFeatures: [] } },
 };
-const lighting = (over = {}) => spotLighting({ graphics: GRAPHICS, quality: 1, rendererIndex: 0, renderSettings: RENDER_SETTINGS,
-                                               lights: [], what: "home spot 1", ...over });
+const lighting = (over = {}) => spotLighting(lightingResources({ graphics: GRAPHICS, quality: 1, rendererIndex: 0, renderSettings: RENDER_SETTINGS,
+                                               lights: [], what: "home spot 1", ...over }));
 
 test("spotLighting: keywords of the quality level's pipeline asset, no light, URP's default light constants", () => {
   const best = lighting();
-  assert.equal(best.pipeline, "Best"); assert.equal(best.renderer, "Runtime");
+  assert.equal(best.pipeline.m_Name, "Best"); assert.equal(best.renderer.m_Name, "Runtime");
   // Auto SH evaluation is per vertex on GLES3; the additional lights keyword stays on without an additional light
   assert.deepEqual(best.keywords, ["EVALUATE_SH_VERTEX", "_ADDITIONAL_LIGHTS_VERTEX"]);
   assert.deepEqual(lighting({ quality: 0 }).keywords, ["EVALUATE_SH_VERTEX"]);
-  assert.equal(lighting({ rendererIndex: -1 }).renderer, "Editor");
+  assert.equal(lighting({ rendererIndex: -1 }).renderer.m_Name, "Editor");
   const g = (p) => ({ ...GRAPHICS, pipelines: { ...GRAPHICS.pipelines, Best: pipeline(p) } });
   assert.deepEqual(lighting({ graphics: g({ m_ShEvalMode: 3, m_AdditionalLightsRenderingMode: 1 }) }).keywords, ["_ADDITIONAL_LIGHTS"]);
   assert.deepEqual(lighting({ graphics: g({ m_ShEvalMode: 2, m_ReflectionProbeBlending: 1 }) }).keywords,
                    ["EVALUATE_SH_MIXED", "_REFLECTION_PROBE_BLENDING"]);
-  assert.deepEqual(lighting({ graphics: { ...GRAPHICS, qualityLevels: [{ customRenderPipeline: null }] }, quality: 0 }).pipeline, "Best");
+  assert.deepEqual(lighting({ graphics: { ...GRAPHICS, qualityLevels: [{ customRenderPipeline: null }] }, quality: 0 }).pipeline.m_Name, "Best");
   assert.deepEqual(best.globals._MainLightPosition, [0, 0, 1, 0]);
   assert.deepEqual(best.globals._MainLightColor, [0, 0, 0, 1]);
   assert.deepEqual(best.globals._AdditionalLightsCount, [0, 0, 0, 0]);
@@ -517,7 +539,7 @@ const litStore = (renderSettings = RENDER_SETTINGS, home = {}) => {
   const mats = [MATERIALS[0], litMat];
   const ms = [card("near", -4, 0), card("wall", -6, 1, { normals: [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1] })];
   const nodes = ms.map((m) => ({ path: `room/${m.name}`, active: true, renderQueue: null }));
-  const hostDoc = { format: "ournotes.story-host/1", kind: "home", home: {
+  const hostDoc = { kind: "home", home: {
     spotId: 1, talk: "area", characterId: null, spot: "host/spot/spot.json", room: "host/spot/room.glb", roomNodes: nodes,
     roomMaterials: mats, situation: { name: "s", matched: true },
     sceneRoot: { objRoot: null, lights: [], volumes: [], renderSettings }, lights: [], volume: null, spineMaterials: {},
@@ -555,7 +577,7 @@ test("host: a drawn Lit room gets URP's lighting keywords, normals, light consta
   const { store, host } = litStore();
   const { gl, calls } = litGL();
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(gl, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null,
+  const h = await createHome(gl, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null,
                                                                   post: postLib() });
   const litPrograms = [...h.lib.cache.values()].filter((p) => p.label.startsWith(LIT));
   assert.deepEqual(litPrograms.map((p) => p.label), [`${LIT}#0.0[EVALUATE_SH_VERTEX _ADDITIONAL_LIGHTS_VERTEX]`]);
@@ -576,7 +598,7 @@ test("host: a drawn Lit room gets URP's lighting keywords, normals, light consta
   h.dispose();
   // a lower quality level: no additional lights keyword
   const low = litStore();
-  const h2 = await SimpleHomeHost.create(litGL().gl, low.store, new PlayerLoop(30), low.host,
+  const h2 = await createHome(litGL().gl, low.store, new PlayerLoop(30), low.host,
                                          { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 0, spine: null, post: postLib() });
   assert.deepEqual([...h2.lib.cache.values()].filter((p) => p.label.startsWith(LIT)).map((p) => p.label), [`${LIT}#0.0[EVALUATE_SH_VERTEX]`]);
   h2.dispose();
@@ -585,7 +607,7 @@ test("host: a drawn Lit room gets URP's lighting keywords, normals, light consta
 test("host: a drawn session checks the lighting before any GL call", async () => {
   const { store, host } = litStore({ ...RENDER_SETTINGS, m_Fog: 1 });
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(null, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null });
+  const h = await createHome(null, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null });
   h.gl = new Proxy({}, { get: () => { throw new Error("GL call"); } });
   await assert.rejects(h._upload(), /home spot 1: scene fog is not reproduced/);
   h.graphics = null;
@@ -675,7 +697,7 @@ test("host: the main camera draws the spot into its HDR colour target, then its
   const { store, host } = litStore(RENDER_SETTINGS, { volume: spotVol() });
   const { gl, calls } = litGL();
   const loop = new PlayerLoop(30), post = postLib();
-  const h = await SimpleHomeHost.create(gl, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null, post });
+  const h = await createHome(gl, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null, post });
   assert.deepEqual(h.missing, []);
   assert.equal(h.volumeStack.Bloom.intensity, F(4 * F(0.05)));
   const target = new GLTarget(gl, 64, 32, { label: "SimpleScreen" });
@@ -712,7 +734,7 @@ test("host: the main camera draws the spot into its HDR colour target, then its
   // HDR needs the pipeline asset's support as well as the camera's: RGBA8 otherwise
   const ldr = litStore(RENDER_SETTINGS, { volume: spotVol() }), g2 = litGL();
   const graphics = { ...GRAPHICS, pipelines: { ...GRAPHICS.pipelines, Best: pipeline({ m_AdditionalLightsRenderingMode: 2, m_SupportsHDR: 0 }) } };
-  const h2 = await SimpleHomeHost.create(g2.gl, ldr.store, new PlayerLoop(30), ldr.host,
+  const h2 = await createHome(g2.gl, ldr.store, new PlayerLoop(30), ldr.host,
                                          { camera: DRAWN_CAM, graphics, quality: 1, spine: null, post: postLib() });
   assert.equal(h2.hdr, false);
   g2.calls.length = 0;
@@ -734,7 +756,7 @@ test("host: the film grain follows the host option; the grain textures load only
     const { gl } = litGL();
     bindAssets(gl, store);
     const p = postLib();
-    const h = await SimpleHomeHost.create(gl, store, new PlayerLoop(30), host,
+    const h = await createHome(gl, store, new PlayerLoop(30), host,
                                           { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null, post: { ...post, lib: p.lib } });
     const target = new GLTarget(gl, 64, 32, { label: "SimpleScreen" });
     h.render(target, 64, 32);
@@ -761,11 +783,11 @@ test("host: the film grain follows the host option; the grain textures load only
 test("host: a drawn session refuses a spot volume or camera setting the chain does not draw, before any GL call", async () => {
   const { store, host } = litStore(RENDER_SETTINGS, { volume: spotVol({ isGlobal: false }) });
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(null, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null,
+  const h = await createHome(null, store, loop, host, { camera: DRAWN_CAM, graphics: GRAPHICS, quality: 1, spine: null,
                                                                    post: postLib() });
   assert.deepEqual(h.missing, []);                                                  // a headless session plays it
   h.gl = new Proxy({}, { get: () => { throw new Error("GL call"); } });
-  await assert.rejects(h._upload(), /home spot 1: local Volume bg/);
+  await assert.rejects(h._upload(), /home spot 1: local Volume .*bg/);
   h.postOpts = {};
   await assert.rejects(h._upload(), /needs the story's shaders/);
   h.cameraSettings = { ...DRAWN_CAM, antialiasing: 1 };
@@ -776,7 +798,7 @@ test("host: a drawn session refuses a spot volume or camera setting the chain do
 
 test("host: an unknown character keeps the camera still and resolves", async () => {
   const { store, host } = makeStore();
-  const loop = new PlayerLoop(30), h = await SimpleHomeHost.create(null, store, loop, host, { camera: CAM, spine: null });
+  const loop = new PlayerLoop(30), h = await createHome(null, store, loop, host, { camera: CAM, spine: null });
   const p = { ...h.camera.position }, warn = console.warn;
   let warned = 0;
   console.warn = () => { warned++; };
@@ -788,17 +810,17 @@ test("host: an unknown character keeps the camera still and resolves", async ()
 
 test("host: a tap talk whose character has no SpotCharacter in the spot is listed in missing", async () => {
   const { store, host } = makeStore({ home: { characterId: 16 } });
-  const h = await SimpleHomeHost.create(null, store, new PlayerLoop(30), host, { camera: CAM, spine: null });
+  const h = await createHome(null, store, new PlayerLoop(30), host, { camera: CAM, spine: null });
   assert.equal(h.tapTarget(16), null);
   assert.equal(h.tapTarget(3).path, "s/A");
   assert.ok(h.missing.includes(NO_TAP_TARGET));
   h.dispose();
   const ok = makeStore();
-  const h2 = await SimpleHomeHost.create(null, ok.store, new PlayerLoop(30), ok.host, { camera: CAM, spine: null });
+  const h2 = await createHome(null, ok.store, new PlayerLoop(30), ok.host, { camera: CAM, spine: null });
   assert.equal(h2.missing.includes(NO_TAP_TARGET), false);
   h2.dispose();
   const area = makeStore({ home: { talk: "area", characterId: null } });                 // area talks focus nobody
-  const h3 = await SimpleHomeHost.create(null, area.store, new PlayerLoop(30), area.host, { camera: CAM, spine: null });
+  const h3 = await createHome(null, area.store, new PlayerLoop(30), area.host, { camera: CAM, spine: null });
   assert.equal(h3.missing.includes(NO_TAP_TARGET), false);
   h3.dispose();
 });
@@ -908,7 +930,7 @@ test("spine: skeletons start at the initial animation's end state, update in the
     ] } }));
   store._text.set("host/spot/spine/a.atlas", "a.png\nb.png\n");
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(null, store, loop, host, { camera: CAM, spine: runtime });
+  const h = await createHome(null, store, loop, host, { camera: CAM, spine: runtime });
   assert.deepEqual(h.missing, []);
   assert.equal(h.skeletons.length, 1);
   const s = h.skeletons[0];
@@ -942,7 +964,7 @@ test("spine: skeletons start at the initial animation's end state, update in the
   assert.deepEqual(log, []);
 });
 
-test("spine: host.json's per-character sortingOrder and page materials, advui material records", async () => {
+test("spine: per-character sorting order and atlas page material objects", async () => {
   const { runtime } = makeFakeSpine();
   const anim = { _animationName: "home_start", loop: 0, timeScale: 1, initialSkinName: "", initialFlipX: 0, initialFlipY: 0,
                  pmaVertexColors: 1, tintBlack: 0, zSpacing: 0 };
@@ -960,13 +982,13 @@ test("spine: host.json's per-character sortingOrder and page materials, advui ma
     animations: [{ name: "home_start", duration: 1 }], slots: [{ x: 0, y: 0, attachment: { type: "region", page: "a.png" } }] } }));
   store._text.set("host/spot/spine/a.atlas", "a.png\nb.png\n");
   const loop = new PlayerLoop(30);
-  const h = await SimpleHomeHost.create(null, store, loop, host, { camera: CAM, spine: runtime });
+  const h = await createHome(null, store, loop, host, { camera: CAM, spine: runtime });
   assert.equal(h.skeletons[0].sortingOrder, 3);
   const b = h.pageMaterials.get("b.png");
-  assert.equal(b.name, "b_Material");
+  assert.equal(b.material, "b_Material");
   assert.equal(b.shader, "Universal Render Pipeline/Spine/Skeleton");
-  assert.deepEqual(b.texEnvs, { _MainTex: { scale: [2, 1], offset: [0, 0.5] } });
-  assert.equal(h.pageMaterials.get("a.png").name, "a_Material");
+  assert.deepEqual(b.textures, { _MainTex: { texture: { name: "a" }, scale: { x: 2, y: 1 }, offset: { x: 0, y: 0.5 } } });
+  assert.equal(h.pageMaterials.get("a.png").material, "a_Material");
   h.dispose();
   // two characters naming different materials for one page: refused
   const spot2 = { ...spot, spineCharacters: [...spot.spineCharacters, { ...spot.spineCharacters[0], path: "s/B" }] };
@@ -974,6 +996,6 @@ test("spine: host.json's per-character sortingOrder and page materials, advui ma
     { path: "s/B", sortingOrder: 0, pageMaterials: { "a.png": "b_Material" } }] } });
   bad.store._text.set("host/spot/spine/a.json", store.text("host/spot/spine/a.json"));
   bad.store._text.set("host/spot/spine/a.atlas", "a.png\nb.png\n");
-  await assert.rejects(SimpleHomeHost.create(null, bad.store, new PlayerLoop(30), bad.host, { camera: CAM, spine: runtime }),
-                       /atlas page a\.png has the materials a_Material and b_Material/);
+  await assert.rejects(createHome(null, bad.store, new PlayerLoop(30), bad.host, { camera: CAM, spine: runtime }),
+                       /atlas page a\.png: conflicting materials/);
 });
diff --git a/tests/unit/story-simple.test.mjs b/tests/unit/story-simple.test.mjs
index 1a73b78..c8fb0bd 100644
--- a/tests/unit/story-simple.test.mjs
+++ b/tests/unit/story-simple.test.mjs
@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
+import { AnimClip } from "../../src/engine/anim.js";
+import { Prefab } from "../../src/engine/prefab.js";
+import { uiResources } from "./story-ui-resources.mjs";
 import { PlayerLoop } from "../../src/engine/loop.js";
 import { UINode } from "../../src/engine/ugui.js";
 import { LAYOUT_DEFAULT, SIMPLE_RT_SIZE, SLOT_LAYOUT, STAGE_X } from "../../src/story/simple/define.js";
@@ -218,28 +221,31 @@ const spriteRec = (x) => ({ texture: "t", rect: { x, y: 0, width: 4, height: 4 }
                             textureRectOffset: { x: 0, y: 0 }, border: { x: 0, y: 0, z: 0, w: 0 }, pixelsPerUnit: 100,
                             pivot: { x: 0.5, y: 0.5 } });
 const hostDoc = () => {
-  const node = (path, extra = {}) => ({ ...runtimeNodeRecord(path, path.split("/").pop()), ...extra });
-  return {
-    nodes: [node("W", { animator: { controller: "C", enabled: 1, updateMode: 0, keepStateOnDisable: false } }),
-            node("W/A", { canvasGroup: { m_Enabled: 1, m_Alpha: 1, m_IgnoreParentGroups: false } }),
-            node("W/B", { image: { m_Enabled: 1, sprite: "s1", m_Type: 0, color: { r: 1, g: 1, b: 1, a: 1 } } })],
-    textures: { t: { width: 8, height: 4 } }, sprites: { s1: spriteRec(0), s2: spriteRec(4) },
-    materials: { "Default UI Material": { shader: { shader: "UI/Default" } } },
-    controllers: { C: { name: "C", defaultState: "Idle", states: [{ name: "Idle", speed: 1, clip: null },
-                                                                   { name: "Show", speed: 1, clip: "Show" }] } },
-    clips: { "C/Show": { name: "Show", startTime: 0, stopTime: 1, loopTime: false, events: [],
-      pptrCurveMapping: ["s1", "s2"],
-      curves: {
-        "A:CanvasGroup.m_Alpha": { keys: [[-3.4028234663852886e38, 0, 0, 0, 0], [0, 0, 0, 1, 0], [1, 0, 0, 0, 1]] },
-        "B:Image.m_Sprite": { discrete: [[-3.4028234663852886e38, 0], [0.5, 1]] },
-        "#123:CanvasGroup.m_Alpha": { constant: 0 },
-        "Gone:CanvasGroup.m_Alpha": { constant: 0 },
-      } } },
-  };
+  const node = (path, components) => ({ ...runtimeNodeRecord(path, path.split("/").pop()), components });
+  const component = (cls, fields) => ({ type: cls, fields });
+  const nodes = [node("W", [component("Animator", { m_Controller: "C", m_Enabled: 1, m_UpdateMode: 0 })]),
+    node("W/A", [component("CanvasGroup", { m_Enabled: 1, m_Alpha: 1 })]),
+    node("W/B", [component("Image", { m_Enabled: 1, m_Sprite: "s1", m_Type: 0, m_Color: { r: 1, g: 1, b: 1, a: 1 } })])];
+  const clip = AnimClip.fromObject({ name: "Show", startTime: 0, stopTime: 1, cycleOffset: 0, loopTime: false,
+    dense: { curveCount: 0 }, constant: [0, 0], pptrCurveMapping: ["s1", "s2"],
+    streamed: { curveCount: 1, discreteCurveCount: 1, frames: [[-3e38, [[0, 0, 0, 0, 0], [1, 0, 0, 0, 0]]],
+      [0, [[0, 0, 0, 1, 0]]], [0.5, [[1, 0, 0, 0, 1]]], [1, [[0, 0, 0, 0, 1]]]] },
+    bindings: [{ class: "CanvasGroup" }, { class: "MonoBehaviour", scriptClass: "Test||Image", typeID: 114, pptr: true },
+      { class: "CanvasGroup" }, { class: "CanvasGroup" }] },
+    [{ path: "A", attribute: "m_Alpha" }, { path: "B", attribute: "m_Sprite" }, { path: null, attribute: "m_Alpha" },
+      { path: "Gone", attribute: "m_Alpha" }]);
+  const ctrl = { name: "C", defaultState: 0, anyState: [], parameters: new Map(), clipList: [clip],
+    states: [{ name: "Idle", speed: 1, clip: null, transitions: [] }, { name: "Show", speed: 1, clip, transitions: [] }] };
+  const objects = { assets: null, mono: () => ({ defaultEaseType: 6 }), id: (v) => v || null,
+    prefab: () => new Prefab({ key: "fixture:W", nodes }), controller: () => ctrl,
+    sprite: (id) => ({ ...spriteRec(id === "s1" ? 0 : 4), pixelsToUnits: 100, texture: { id: "t", width: 8, height: 4 } }) };
+  return { doc: { settings: { dotween: "D" } }, objects, roots: [{ id: "fixture:W" }] };
 };
 
 test("host UI animator: child-path bindings, discrete sprite curves, unresolved and missing paths", () => {
-  const doc = new SimpleUIDoc(null, null, hostDoc(), { assets: null, dir: "host/ui" });
+  const fixture = hostDoc();
+  const doc = new SimpleUIDoc(null, null, fixture.doc, fixture);
+  assert.equal(doc.sprites.has("s2"), true, "preloads sprites used only by a later key");
   const w = doc.node("W"), a = doc.node("W/A"), b = doc.node("W/B");
   assert.deepEqual(doc.unbound, ["C: Gone"]);                          // "#123": unresolved in the game data, skipped
   assert.equal(w.animator.play("Show"), true);
@@ -290,7 +296,8 @@ const W = "UISimpleAdvTalkWindow", TT = `${W}/TalkArea/Content/TextWindow/TalkTe
 const simpleWindowDoc = () => {
   const n = (path, extra = {}) => ({ ...runtimeNodeRecord(path, path.split("/").pop()), ...extra });
   return {
-    nodes: [n(W, { talkWindow: { _typingDelay: 0.05, _useBackdropFilter: 0 } }), n(`${W}/TalkArea`), n(`${W}/TalkArea/Content`),
+    nodes: [n(W, { talkWindow: { _typingDelay: 0.05, _useBackdropFilter: 0, TalkArea: { gameObject: `${W}/TalkArea` },
+      TalkText: { gameObject: TT }, SpeakerText: { gameObject: ST }, _speakerNameObjects: [{ gameObject: `${W}/TalkArea/Content/Speaker` }] } }), n(`${W}/TalkArea`), n(`${W}/TalkArea/Content`),
             n(`${W}/TalkArea/Content/TextWindow`), n(TT, { textStyle: {} }), n(`${W}/TalkArea/Content/Speaker`),
             n(`${W}/TalkArea/Content/Speaker/Back`), n(ST, { textStyle: {} })],
     textures: {}, sprites: {}, materials: { "Default UI Material": { shader: { shader: "UI/Default" } } },
@@ -307,11 +314,17 @@ const simpleFonts = () => ({
            [ST]: tmpBinding("RubyTextMeshProUGUI", { m_fontSize: 36, uiRubyText: { _rubyMarginTop: -24 } }) },
 });
 
+const simpleWindow = (loop, fonts = simpleFonts()) => {
+  const language = { code: "ja", mode: 2 };
+  const resources = uiResources({ ...simpleWindowDoc(), transitions: {}, controllers: {}, clips: {} }, fonts, language);
+  return new SimpleUIDoc(null, loop, resources.doc, { ...resources, fonts: resources.data.fonts, language,
+    roots: [{ id: resources.doc.talkWindows[W] }] });
+};
+
 test("simple talk window: text components over the font data, no background, ruby text typed with its reading", async () => {
   const loop = new PlayerLoop(30), tweens = { active: new Set() };
   loop.on("tweens", (l) => { for (const t of [...tweens.active]) t.step(l.deltaTime); });
-  const doc = new SimpleUIDoc(null, loop, simpleWindowDoc(), { assets: null, dir: "ui/simple", fonts: simpleFonts(),
-                                                              language: { language: "ja", mode: 2 } });
+  const doc = simpleWindow(loop);
   const win = new SimpleTalkWindow(doc, W, { loop, tweens, language: { language: "ja", mode: 2 } });
   const tt = doc.node(TT), st = doc.node(ST);
   assert.equal(tt.storyText.b.class, "RubyEmojiTextMeshProUGUI");
@@ -344,7 +357,7 @@ test("simple talk window: a fallback font's characters are drawn with their fall
   fonts.fonts = { "Test SDF": { ...fontAsset(), fallbacks: ["Fb SDF"] }, "Fb SDF": fb };
   fonts.textures.page1 = { texture: "fonts/page1.png", width: 1024, height: 1024, mipCount: 1 };
   fonts.materials["Test - Simple + Fb SDF"] = { ...fonts.materials["Test - Simple"], material: "Test - Simple + Fb SDF" };
-  const doc = new SimpleUIDoc(null, loop, simpleWindowDoc(), { assets: null, dir: "ui/simple", fonts, language: { language: "ja", mode: 2 } });
+  const doc = simpleWindow(loop, fonts);
   const tt = doc.node(TT);
   tt.rect = { x: 0, y: -200, w: 1000, h: 200 }; tt.matrix = [1, 0, 0, 1, 0, 0];
   tt.text.setText("A\u2605");
diff --git a/tests/unit/story-ui-canvas.test.mjs b/tests/unit/story-ui-canvas.test.mjs
index 614808e..11610d6 100644
--- a/tests/unit/story-ui-canvas.test.mjs
+++ b/tests/unit/story-ui-canvas.test.mjs
@@ -9,6 +9,7 @@ import { test } from "node:test";
 import { F } from "../../src/engine/core.js";
 import { PlayerLoop } from "../../src/engine/loop.js";
 import { StoryCommandError, checkStoryUI } from "../../src/story/interfaces.js";
+import { uiResources } from "./story-ui-resources.mjs";
 import { StoryUI } from "../../src/story/ui.js";
 import { hasRubyInFirstLine, netSingleToString, replaceRubyTags } from "../../src/story/ui-ruby.js";
 import { StoryTalkWindow, countRenderedCharacters, removeTagsKeepingRuby, removeTagsWithRuby } from "../../src/story/ui-talk.js";
@@ -247,7 +248,8 @@ const fontsDoc = (koAdjust = null) => ({
 });
 const create = ({ mode = 2, lang = "zh-Hant", koAdjust = null, doc = uiDoc(), fonts = fontsDoc(koAdjust), attach = true } = {}) => {
   const loop = new PlayerLoop(30);
-  const ui = new StoryUI(null, loop, doc, { lang, fonts, language: { language: lang, mode, lineSpacing: 5 } });
+  const resources = uiResources(doc, fonts, { code: lang, mode, lineSpacing: 5 });
+  const ui = new StoryUI(null, loop, resources.doc, resources);
   if (attach) ui.setTalkWindow("UIDefaultTalkWindow");                  // AdvPlayer PlayInitialCommands
   return { loop, ui, step: async (n = 1) => { for (let i = 0; i < n; i++) await loop.step(); } };
 };
@@ -272,7 +274,7 @@ test("StoryUI contract, the state after Refresh and the loaded window before and
   ui.layout(2340, 1080);
   assert.deepEqual(ui.drawList(ui.front).map((it) => it.node.name), []);  // no window attached yet
   assert.equal(ui.isShowingTalk(), false);
-  assert.equal(ui.trueCanvasSortOrder, null);
+  assert.equal(ui.trueCanvasSortOrder, 99999);
   assert.equal(ui.talkShakeTarget(), null);
   assert.equal(ui.talk, null);
   ui.setTalkWindow("UIDefaultTalkWindow");
@@ -660,7 +662,7 @@ test("video buttons: shown with or without skip, laid out, the black filter on t
 test("talk window without background, indicator and icons (optional references)", async () => {
   const { ui, step } = create();
   const fake = { part: { ...Win(ui), background: null, nextIndicator: null, autoIcon: null, fastIcon: null },
-                 loop: ui.loop, tweens: ui.tweens, language: ui.language, doc: ui.doc, setActive: (n, v) => ui.setActive(n, v) };
+                 loop: ui.loop, tweens: ui.tweens, language: ui.language, dotween: ui.dotween, setActive: (n, v) => ui.setActive(n, v) };
   const w = new StoryTalkWindow(fake);
   w.refresh();
   w.showTalk();
@@ -783,7 +785,7 @@ test("centre talk window: the UI blur is on (rate 1 at once) while its talk area
   assert.equal(ui.blur.enabled, false);
   // a centre window without the blur settings in the data is refused
   const doc = withCenter(uiDoc()); delete doc.blur;
-  assert.throws(() => create({ doc, fonts: withCenterFonts(fontsDoc()) }), /lacks `blur`/);
+  assert.throws(() => create({ doc, fonts: withCenterFonts(fontsDoc()) }), /lack a UI blur feature/);
 });
 
 test("centre talk window: the blur pass runs on the render target while the blur is on", () => {
diff --git a/tests/unit/story-ui-chat.test.mjs b/tests/unit/story-ui-chat.test.mjs
index 6f83d11..53eebad 100644
--- a/tests/unit/story-ui-chat.test.mjs
+++ b/tests/unit/story-ui-chat.test.mjs
@@ -1,3 +1,5 @@
+import { chatWidgetPrefab } from "./story-chat-resources.mjs";
+import { nativeComponent } from "./story-screen-resources.mjs";
 // The chat phone's uGUI pieces on synthetic inputs: stencil states of masks and masked graphics, chat sprites (trimmed
 // sliced inner uv), the Soft Mask parameters, the ScrollRect positions, node copies, the canvas draw list and the
 // Screen Space - Camera globals, the sprite constants in the globals of a canvas.
@@ -17,7 +19,7 @@ const rect = (aMin, aMax, pos, size, pivot = { x: 0.5, y: 0.5 }) => ({ m_AnchorM
 const FULL = rect({ x: 0, y: 0 }, { x: 1, y: 1 }, { x: 0, y: 0 }, { x: 0, y: 0 });
 const C = { x: 0.5, y: 0.5 };
 const node = (path, r = FULL, components = [], active = true) => ({ path, name: path.split("/").pop(), active, layer: 5,
-  localPosition: Z, localRotation: Q, localScale: ONE, rect: r, components });
+  localPosition: Z, localRotation: Q, localScale: ONE, rect: r, components: components.map(nativeComponent) });
 const image = (extra = {}) => ({ type: "MonoBehaviour", class: "Image", m_Enabled: 1, m_Material: null, m_Sprite: null,
   m_Color: { r: 1, g: 1, b: 1, a: 1 }, m_Type: 0, m_PreserveAspect: 0, m_FillCenter: 1, m_PixelsPerUnitMultiplier: 1,
   m_UseSpriteMesh: 0, ...extra });
@@ -34,14 +36,14 @@ test("stencil states: masked graphics at a depth, a mask's push and pop at depth
     pop: { ref: 1, comp: 3, op: 2, read: 1, write: 3, colorMask: 0, alphaClip: true } });
 });
 
-const spriteRec = (over = {}) => ({ sprite: "s", rect: { x: 10, y: 20, width: 100, height: 80 }, border: { x: 10, y: 8, z: 12, w: 6 },
+const spriteRec = (over = {}) => ({ id: "sprite:1", rect: { x: 10, y: 20, width: 100, height: 80 }, border: { x: 10, y: 8, z: 12, w: 6 },
   pixelsToUnits: 100, pivot: C, textureRect: { x: 10, y: 20, width: 100, height: 80 }, textureRectOffset: { x: 0, y: 0 },
-  settingsRaw: 0, texture: { texture: "t.png", width: 256, height: 256 }, ...over });
+  settingsRaw: 0, texture: { id: "texture:1", width: 256, height: 256 }, ...over });
 
 test("chat sprites: the untrimmed inner uv, a trimmed sliced sprite's inner uv from the sprite rect's origin, refusals", () => {
   const a = chatSprite(spriteRec());
   assert.deepEqual(a.inner, [20 / 256, 28 / 256, 98 / 256, 94 / 256]);
-  assert.equal(a.texture.name, "t.png");
+  assert.equal(a.texture.id, "texture:1");
   const b = chatSprite(spriteRec({ textureRect: { x: 12, y: 24, width: 90, height: 70 }, textureRectOffset: { x: 2, y: 4 } }));
   assert.equal(b.trimmed, true);
   // origin (12 - 2, 24 - 4) = (10, 20): the same inner rect as untrimmed
@@ -129,7 +131,7 @@ const widget = () => ({ nodes: [
 ] });
 
 test("the canvas draw list: a mask's push, its masked children at depth 1 with inherited alpha, its pop; hidden objects skipped", () => {
-  const ui = new ChatCanvasUI(widget());
+  const ui = new ChatCanvasUI(chatWidgetPrefab(widget()));
   const top = rect({ x: 0.5, y: 1 }, { x: 0.5, y: 1 }, { x: 0, y: 0 }, { x: 200, y: 400 }, { x: 0.5, y: 1 });
   const recs = [node("win", top), node("win/Mask", FULL, [image(), { type: "MonoBehaviour", class: "Mask", m_Enabled: 1, m_ShowMaskGraphic: 0 }]),
                 node("win/Mask/g", FULL, [{ type: "CanvasGroup", m_Enabled: 1, m_Alpha: 0.5, m_IgnoreParentGroups: 0 }]),
diff --git a/tests/unit/story-ui-resources.mjs b/tests/unit/story-ui-resources.mjs
new file mode 100644
index 0000000..df2139f
--- /dev/null
+++ b/tests/unit/story-ui-resources.mjs
@@ -0,0 +1,90 @@
+import { AnimClip } from "../../src/engine/anim.js";
+import { Prefab } from "../../src/engine/prefab.js";
+
+// Resource doubles for front-canvas state and layout tests. Geometry, components, and font bindings have separate ids.
+export const uiResources = (spec, fonts, language) => {
+  let next = 1;
+  const prefabs = new Map(), bindings = {}, sprites = {};
+  const windows = spec.nodes.filter((n) => n.talkWindow).map((n) => n.path);
+  const cb = (cls, fields) => ({ type: "MonoBehaviour", script: `Test||${cls}`, pathId: String(next++), fields });
+  const rootNode = (path) => ({ path, name: path.split("/").at(-1), active: true,
+    localPosition: { x: 0, y: 0, z: 0 }, localRotation: { x: 0, y: 0, z: 0, w: 1 },
+    localScale: { x: 1, y: 1, z: 1 }, components: [] });
+  const make = (id, source, list) => {
+    const pathOf = (path) => path.replace(source, source.split("/").at(-1));
+    const refs = (v) => {
+      if (typeof v === "string" && v.startsWith("UIAdvWidget/")) return { gameObject: pathOf(v) };
+      if (Array.isArray(v)) return v.map(refs);
+      if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, refs(x)]));
+      return v;
+    };
+    const nodes = list.map((n) => {
+      const r = { ...rootNode(pathOf(n.path)), rect: n.rect, active: n.active, components: [] };
+      for (const k of ["localPosition", "localRotation", "localScale"]) r[k] = n[k];
+      const add = (cls, fields) => { if (fields) r.components.push(cb(cls, fields)); };
+      add("Canvas", n.canvas); add("CanvasScaler", n.canvasScaler); add("CanvasGroup", n.canvasGroup);
+      if (n.image) add("Image", { ...n.image, m_Sprite: n.image.sprite, m_Material: n.image.material });
+      add("HorizontalLayoutGroup", n.layoutGroup); add("ContentSizeFitter", n.contentSizeFitter); add("LayoutElement", n.layoutElement);
+      add("UIAdvTalkWindow", n.talkWindow); add("AdvFlashView", refs(n.flashView)); add("AdvSubtitlesView", refs(n.subtitlesView));
+      add("AdvTalkLogView", refs(n.talkLogView)); add("AdvChoiceView", refs(n.choiceView));
+      if (n.ruleTransition) add("UIAdvRuleTransitionView", { _material: n.ruleTransition.material });
+      if (n.tweenSequence) add("DOTweenSequence", { ...n.tweenSequence.raw, _list: n.tweenSequence.list });
+      if (n.buttonImageState) add("ButtonImageState", { _target: refs(n.buttonImageState.target), _normaledSprite: n.buttonImageState.normal });
+      if (n.safeAreaEdgeAnchor) add("UISafeAreaEdgeAnchor", { ...n.safeAreaEdgeAnchor, m_Enabled: n.safeAreaEdgeAnchor.enabled });
+      for (const [cls, records] of Object.entries(n.behaviours || {})) for (const record of records) add(cls, refs(record));
+      if (n.animator) add("Animator", { m_Controller: n.animator.controller, m_Enabled: n.animator.enabled,
+        m_UpdateMode: n.animator.updateMode, m_KeepAnimatorStateOnDisable: n.animator.keepStateOnDisable });
+      if (n.textStyle) {
+        const t = fonts.texts[n.path], c = cb(t.class, { ...t, ...t.ruby, m_Enabled: t.enabled });
+        r.components.push(c);
+        bindings[`fixture:${c.pathId}`] = { style: n.textStyle, font: t.localized, localizeKoreanAdjust: t.localizeKoreanAdjust };
+        if (t.spriteAsset) sprites[`fixture:${c.pathId}`] = { spriteAsset: t.spriteAsset };
+        add("UIRubyText", t.uiRubyText);
+      }
+      return r;
+    });
+    if (nodes[0]?.path !== pathOf(source)) nodes.unshift(rootNode(pathOf(source)));
+    const p = new Prefab({ key: id, nodes });
+    prefabs.set(id, p);
+    return p;
+  };
+  const widgetNodes = spec.nodes.filter((n) => !windows.some((w) => n.path === w || n.path.startsWith(`${w}/`)));
+  const widget = make("fixture:widget", "UIAdvWidget", widgetNodes);
+  const canvases = spec.widget?.canvases || [];
+  for (const c of canvases) if (!widget.nodes.has(c.path)) {
+    const n = rootNode(c.path); n.components.push(cb("Canvas", { m_SortingOrder: c.sortingOrder }));
+    widget.nodes.set(c.path, { node: n });
+  }
+  widget.nodes.get("UIAdvWidget").node.components.push(cb("UIAdvWidget", { _canvases: canvases.map((c) => ({ gameObject: c.path })) }));
+  const talkWindows = Object.fromEntries(windows.map((w, i) => {
+    const id = `fixture:window${i}`;
+    make(id, w, spec.nodes.filter((n) => n.path === w || n.path.startsWith(`${w}/`)));
+    return [w.split("/").at(-1), id];
+  }));
+  const objects = {
+    prefab: (id) => prefabs.get(id), id: (id) => id || null,
+    mono: (id) => id === "dotween" ? spec.dotween : spec.transitions[id],
+    uiBlur: () => spec.blur || null,
+    material: (id) => ({ ...spec.materials[id], shader: spec.materials[id].shader.shader }),
+    sprite: (id) => ({ ...spec.sprites[id], id, name: id, pixelsToUnits: spec.sprites[id].pixelsPerUnit,
+      texture: { ...spec.textures[spec.sprites[id].texture], id: spec.sprites[id].texture } }),
+    controller: (id) => {
+      const ctrl = spec.controllers[id];
+      return { name: ctrl.name, defaultState: ctrl.states.findIndex((s) => s.name === ctrl.defaultState),
+        states: ctrl.states.map((s) => ({ ...s, writeDefaults: false, transitions: [],
+          clip: spec.clips[`${ctrl.name}/${s.clip}`] ? AnimClip.fromCurves(spec.clips[`${ctrl.name}/${s.clip}`]) : null })),
+        anyState: [], parameters: new Map() };
+    },
+  };
+  for (const v of Object.values(spec.transitions)) v._texture = v._texture?.texture || null;
+  const doc = { widget: "fixture:widget", talkWindows, language, letterbox: spec.letterBoxSprite,
+    settings: { dotween: "dotween" }, graphics: { graphics: "graphics" } };
+  const data = { fonts: { ...fonts, texts: bindings, sprites }, language: language.code, fontDir: "fonts",
+    episode: { commands: Object.keys(talkWindows).map((name) => ({ cmd: "TalkWindow", TargetAssetName: name })) },
+    asset: (address) => {
+      const key = address.slice("Adv/Transition/".length);
+      if (!spec.transitions[key]) throw new Error(`${address}: not in the data`);
+      return { objects: [key] };
+    } };
+  return { doc, data, objects };
+};
diff --git a/tests/unit/story-validation-fixture.mjs b/tests/unit/story-validation-fixture.mjs
new file mode 100644
index 0000000..9cf3e8c
--- /dev/null
+++ b/tests/unit/story-validation-fixture.mjs
@@ -0,0 +1,172 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ModelObjects, mb, node, ref } from "./live2d-objects.mjs";
+import { modelObjects, modelProduct, png, putAsset, putFiles } from "./site-fixture.mjs";
+
+export const TMP = "TextMeshPro/Mobile/Distance Field";
+export const GL_SOURCE = "#ifdef VERTEX\n#version 300 es\nvoid main() {}\n#endif\n#ifdef FRAGMENT\n#version 300 es\nvoid main() {}\n#endif\n";
+export const textFields = (s) => ({ japanese: s, english: s, traditionalChinese: s, simplifiedChinese: s, korean: s });
+export const flac = (sampleRate, channels, samples) => {
+  const b = Buffer.alloc(42); b.write("fLaC"); b[7] = 34;
+  const s = b.subarray(8);
+  s[10] = sampleRate >> 12; s[11] = (sampleRate >> 4) & 0xff; s[12] = ((sampleRate & 0xf) << 4) | ((channels - 1) << 1);
+  s[13] = (15 << 4) | Math.floor(samples / 2 ** 32); s.writeUInt32BE(samples % 2 ** 32, 14);
+  return b;
+};
+const language = (code) => ({ code, mode: code === "ja" ? 0 : 1, field: code === "ja" ? "japanese" : "english",
+  lineSpacing: 0, fontNames: [], additionalFontNames: [], materialTypes: [], fontSwap: {} });
+
+export const validationFixture = () => {
+  const o = new ModelObjects("fixture");
+  const shader = o.shader(TMP, { properties: [], subShaders: [{ passes: [{ state: {} }] }] }, [[[], GL_SOURCE], [["OUTLINE_ON"], GL_SOURCE]]);
+  const texture = o.texture("image", { image: png(4, 4) });
+  const sprite = o.add("Sprite", "image", { json: JSON.stringify({ sprite: { m_Name: "image", m_Rect: { x: 0, y: 0, width: 4, height: 4 } },
+    renderData: { texture: ref(texture), uvTransform: { x: 1, y: 0, z: 1, w: 0 } } }) });
+  const textId = "fixture:1000";
+  const text = { ...mb("TextMeshProUGUI", { m_Enabled: 1, m_fontSize: 40, m_text: "", m_tintAllSprites: true }), pathId: "1000" };
+  const prefab = o.prefab([node("Widget", [mb("UIAdvWidget")]), node("Widget/Text", [text])]);
+  // Keep explicit component ids for the font product's bindings.
+  const pf = JSON.parse(o.objects[prefab].files.json); pf.nodes[1].components[0].pathId = "1000";
+  o.objects[prefab].files.json = JSON.stringify(pf);
+  const player = o.mono("AdvPlayerSettings", "settings", { _initializeEpisodes: [], _finalizeEpisodes: [] });
+  const masterIds = o.mono("AdvMasterIdSettings", "ids");
+  const dotween = o.mono("DOTweenSettings", "tweens", { defaultEaseType: 6 });
+  const localize = o.mono("LocalizeManager", "language");
+  const tmp = o.mono("TMP_Settings", "TMP", { m_missingGlyphCharacter: 0 });
+  const graphics = o.add("GraphicsSettings", "graphics", { json: "{}" });
+  const quality = o.add("QualitySettings", "quality", { json: "{}" });
+  const settings = o.add("PlayerSettings", "player", { json: "{}" });
+  const render = o.add("RenderSettings", "render", { json: "{}" });
+  const products = new Map();
+  const add = (file, product, subject, files, objects = {}) => {
+    const p = { schema: "nnnotes.product/1", product, subject, files, objects };
+    products.set(file, p); return p;
+  };
+  const episode = { advId: 7, asset: "episode", commandCount: 2,
+    commands: [{ i: 0, cmd: "Bgm", raw: 15, BgmID: 1 }, { i: 1, cmd: "Talk", raw: 2, AdvTextID: "t1" }],
+    text: { t1: textFields("Hi") }, sounds: { 1: { _soundCueSheetID: 5, _cueName: "bgm_a" } },
+    cuesheets: { 5: { _cueSheetName: "sheet_a" } }, videos: {}, resources: [],
+    master: { _id: 7, _sheetName: "s", _advEpisodeAsset: "episode", _titleTextId: "t0", _rubyTitleTextId: "", _playbackMode: 0 }, title: textFields("T") };
+  const story = { format: 1, advId: 7, episode: "episode.json", chats: {}, effects: {}, parts: {
+    scene: "storyscenes/default.json", models: {}, assets: {}, sounds: { sheet_a: "cuesheets/sheet_a.json" },
+    ui: {}, fonts: {}, videos: {} } };
+  const manifest = add("stories/7.json", "story", "7", { "story.json": story, "episode.json": episode });
+  manifest.language = "ja";
+  const scene = { format: 1, scene: [prefab], renderSettings: render,
+    prefabs: Object.fromEntries(["cameraManager", "backgroundField", "characterField", "globalVolume"].map((k) => [k, prefab])),
+    settings: { playerSettings: player, masterIdSettings: masterIds }, graphics: { graphics, quality, player: settings },
+    bindings: {}, shaders: { [TMP]: shader } };
+  add(story.parts.scene, "story.scene", "default", { "scene.json": scene }, o.objects);
+  const fonts = {}, ui = {};
+  for (const lang of ["ja", "en"]) {
+    const f = font(lang);
+    const raw = f.doc.texts["W/Talk"], binding = { font: raw.localized, localized: raw.localized, style: { class: raw.class } };
+    fonts[lang] = { ...f.doc, format: "nnnotes.story-fonts/1", texts: { [textId]: binding }, shaders: { [TMP]: shader }, sprites: {} };
+    ui[lang] = { format: 1, language: language(lang), widget: prefab, chatWidget: prefab, uiManager: prefab,
+      letterbox: sprite, talkWindows: { Window: prefab }, dialogs: {}, clips: {}, controllers: {},
+      settings: { dotween, tmpSettings: tmp, localizeManager: localize, masterIdSettings: masterIds },
+      graphics: { graphics }, texts: { [textId]: { localized: raw.localized, style: { class: raw.class } } },
+      textStyle: {}, bindings: {}, shaders: { [TMP]: shader } };
+    story.parts.ui[lang] = `storyui/${lang}.json`; story.parts.fonts[lang] = `storyfonts/7_${lang}.json`;
+    add(story.parts.ui[lang], "story.ui", lang, { "ui.json": ui[lang] });
+    add(story.parts.fonts[lang], "story.fonts", `7/${lang}`, { "fonts.json": fonts[lang], [`fonts/${f.page}.png`]: png(16, 12) }, { [shader]: o.objects[shader] });
+  }
+  const cues = { bgm_a: { file: "a.flac", sampleRate: 48000, channels: 2, samples: 48, categories: ["Bgm"] } };
+  add(story.parts.sounds.sheet_a, "story.sound", "sheet_a", { "cues.json": cues, "a.flac": flac(48000, 2, 48) });
+  return { o, products, add, episode, story, scene, fonts, ui, cues, manifest, textId, prefab, shader, texture, sprite,
+    player, tmp, graphics, modelOptions: null, where: "stories/7.json", encoding: null };
+};
+
+export const writeFixture = (dir, f) => {
+  if (f.modelOptions) {
+    const model = modelProduct(dir, modelObjects("m1", f.modelOptions), f.encoding);
+    fs.mkdirSync(path.join(dir, "models"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "models/m1.json"), JSON.stringify(model));
+    f.story.parts.models[model.subject] = "models/m1.json";
+  }
+  const manifests = new Map();
+  for (const [file, p] of f.products) {
+    const target = file === "stories/7.json" ? f.where : file;
+    const packed = { ...p, files: putFiles(dir, p.files, f.encoding), objects: Object.fromEntries(Object.entries(p.objects).map(([id, object]) =>
+      [id, { ...object, files: Object.fromEntries(Object.entries(object.files).map(([role, value]) => [role,
+        putAsset(dir, role === "image" ? "image.png" : role.startsWith("program:") ? "program.glsl" : `${role}.json`, value, f.encoding)])) }])) };
+    fs.mkdirSync(path.dirname(path.join(dir, target)), { recursive: true });
+    fs.writeFileSync(path.join(dir, target), JSON.stringify(packed));
+    manifests.set(target, packed);
+  }
+  return manifests;
+};
+
+const font = (lang) => {
+  const page = `font_Test ${lang}_0`;
+  const face = Object.fromEntries(["m_PointSize", "m_Scale", "m_UnitsPerEM", "m_LineHeight", "m_AscentLine", "m_CapLine", "m_MeanLine", "m_Baseline",
+    "m_DescentLine", "m_SuperscriptOffset", "m_SuperscriptSize", "m_SubscriptOffset", "m_SubscriptSize", "m_UnderlineOffset",
+    "m_UnderlineThickness", "m_StrikethroughOffset", "m_StrikethroughThickness", "m_TabWidth"].map((k) => [k, 1]));
+  return {
+    page,
+    doc: {
+      format: "nnnotes.story-fonts/1", language: lang, source: "open",
+      fonts: { "Test SDF": {
+        faceInfo: { ...face, m_FamilyName: "Test", m_StyleName: "Regular", m_FaceIndex: 0 },
+        atlasWidth: 16, atlasHeight: 16, atlasPadding: 1, atlasRenderMode: 4134, atlasPopulationMode: 0, atlases: [page],
+        normalStyle: 0, normalSpacingOffset: 0, boldStyle: 0.75, boldSpacing: 7, italicStyle: 35, tabSize: 10,
+        material: "Test SDF Material", fallbacks: [], glyphPairAdjustmentRecords: 0,
+        characters: { 72: { glyph: 3, scale: 1, elementType: 1 }, 32: { glyph: 1, scale: 1, elementType: 1 } },
+        glyphs: { 3: { metrics: { m_Width: 4, m_Height: 5, m_HorizontalBearingX: 0, m_HorizontalBearingY: 5, m_HorizontalAdvance: 5 },
+                       rect: { m_X: 2, m_Y: 2, m_Width: 4, m_Height: 5 }, scale: 1, atlasIndex: 0, packed: { texture: page, dx: 0, dy: 0 } },
+                  1: { metrics: { m_Width: 0, m_Height: 0, m_HorizontalBearingX: 0, m_HorizontalBearingY: 0, m_HorizontalAdvance: 3 },
+                       rect: { m_X: 0, m_Y: 0, m_Width: 0, m_Height: 0 }, scale: 1, atlasIndex: 0 } },
+        runtimeCharacters: [], runtimeGlyphs: null, subset: "the characters shown",
+        source: { family: "Test", style: "Regular", version: "1", license: "OFL", file: "t.ttf", faceIndex: 0, bytes: 1, sha256: "0".repeat(64), generator: {} } } },
+      textures: { [page]: { texture: `fonts/${page}.png`, name: page, width: 16, height: 12, mipCount: 1,
+                            settings: { m_FilterMode: 1, m_WrapU: 1, m_WrapV: 1 } } },
+      materials: { "Test SDF Material": { material: "Test SDF Material", shader: { shader: TMP }, keywords: [], textures: {}, floats: {}, colors: {} },
+                   "Test - Outline": { material: "Test - Outline", shader: { shader: TMP }, keywords: ["OUTLINE_ON"], textures: {}, floats: {}, colors: {} } },
+      materialKeywords: { "Test SDF Material": [], "Test - Outline": ["OUTLINE_ON"] },
+      texts: { "W/Talk": { class: "TextMeshProUGUI", enabled: 1, fontAsset: "Game SDF", material: "Game - Outline", m_fontSize: 40, m_text: "",
+                           localized: { fontAsset: "Test SDF", material: "Test - Outline", lineSpacing: 0 } } },
+      coverage: { characters: 2, missing: [] },
+      lineBreaking: { leading: "(", following: ")", useModernHangulLineBreakingRules: false },
+    },
+  };
+};
+
+const HEART = 0x2661, VS16 = 0xFE0F, SQUARE = 0x25A1;
+export const withMissingGlyph = (p) => {
+  for (const lang of ["ja", "en"]) {
+    const f = p.fonts[lang], a = f.fonts["Test SDF"];
+    a.characters[SQUARE] = { glyph: 3, scale: 1, elementType: 1 };
+    a.missingGlyph = { unicode: SQUARE, characters: [HEART, VS16] };
+    f.coverage.missingGlyph = [HEART, VS16].map((u) => String.fromCodePoint(u));
+  }
+};
+
+// a fallback font asset: "Fb SDF" (gradient scale 16) behind "Test SDF" (5), its page and default material, and the
+// fallback material of the text material "Test - Outline"; U+53E3 drawn from it
+export const withFallback = (p) => {
+  for (const lang of ["ja", "en"]) {
+    const f = p.fonts[lang], page = `font_Fb ${lang}_0`, test = f.fonts["Test SDF"];
+    const tex = (name, w, h) => ({ _MainTex: { texture: { name, width: w, height: h, format: 4 } } });
+    f.fonts["Fb SDF"] = { ...structuredClone(test), atlases: [page], atlasPadding: 15, material: "Fb SDF Material", fallbacks: [],
+                          characters: { 21475: { glyph: 3, scale: 1, elementType: 1 } } };
+    f.fonts["Fb SDF"].glyphs = { 3: { ...structuredClone(test.glyphs[3]), packed: { texture: page, dx: 0, dy: 0 } } };
+    test.fallbacks = ["Fb SDF"];
+    f.textures[page] = { texture: `fonts/${page}.png`, name: page, width: 16, height: 12, mipCount: 1,
+                         settings: { m_FilterMode: 1, m_WrapU: 1, m_WrapV: 1 } };
+    p.products.get(p.story.parts.fonts[lang]).files[`fonts/${page}.png`] = png(16, 12);
+    const outline = f.materials["Test - Outline"];
+    Object.assign(outline, { textures: tex(`font_Test ${lang}_0`, 16, 12),
+                             floats: { _GradientScale: 5, _FaceDilate: 0, _OutlineWidth: 0.2, _OutlineSoftness: 0, _WeightNormal: 0,
+                                       _WeightBold: 0.5, _UnderlayOffsetX: 0.5, _UnderlayOffsetY: -0.5, _UnderlayDilate: 0,
+                                       _UnderlaySoftness: 0, _ScaleRatioA: 0.8, _ScaleRatioC: 0.7, _TextureWidth: 16, _TextureHeight: 12 } });
+    f.materials["Fb SDF Material"] = { material: "Fb SDF Material", shader: { shader: TMP }, keywords: [], textures: tex(page, 16, 12),
+                                       floats: { _GradientScale: 16, _WeightNormal: 0, _WeightBold: 0.75, _TextureWidth: 16, _TextureHeight: 12 },
+                                       colors: {} };
+    // GetFallbackMaterial: weight 0.75 / 4, t = max(1, 0.1875 + 0.2) = 1 -> A = 15 / 16; C = (15 - 0.1875 * 15) / 16
+    f.materials["Test - Outline + Fb SDF"] = { ...structuredClone(outline), material: "Test - Outline + Fb SDF", textures: tex(page, 16, 12),
+                                               floats: { ...outline.floats, _GradientScale: 16, _WeightBold: 0.75, _ScaleRatioA: 0.9375,
+                                                         _ScaleRatioC: 0.76171875 } };
+    f.materialKeywords["Fb SDF Material"] = [];
+    f.materialKeywords["Test - Outline + Fb SDF"] = ["OUTLINE_ON"];
+  }
+};
diff --git a/types/story.d.ts b/types/story.d.ts
index e4685a6..6eb0426 100644
--- a/types/story.d.ts
+++ b/types/story.d.ts
@@ -170,45 +170,43 @@ export function advViewport(screenWidth: number, screenHeight: number): { x: num
 /** The Talk rows that show a line, in order. */
 export function storyLines(episode: any): StoryCommand[];
 
-/** A story manifest without its file lists. */
+/** The identity, language and product directories of a loaded story store. */
 export interface StoryManifestInfo {
-  format?: string;
-  advId?: number;
-  /** The facts of the story (its listing entry). */
-  story?: { advId?: number; titles?: Record<string, string>; commands?: string[]; playbackMode?: 0 | 1;
-            [key: string]: unknown };
-  /** The default language. */
-  language?: StoryLanguage;
+  schema: "nnnotes.product/1";
+  product: "story";
+  subject: string;
+  advId: number;
+  story: { advId: number; playbackMode: 0 | 1; titles: Partial<Record<StoryLanguage, string>> };
+  language: StoryLanguage;
   /** The language this store holds. */
-  loadedLanguage?: StoryLanguage;
-  audio?: boolean;
-  requires?: { commands?: string[]; cubismCore?: boolean; motionSync?: boolean };
+  loadedLanguage: StoryLanguage;
+  languages: Partial<Record<StoryLanguage, Record<string, never>>>;
+  /** The story's own file directory within the store. */
+  dir: string;
+  /** Product kind -> subject -> file directory within the store. */
+  products: Record<string, Record<string, string>>;
   /** The site root, relative to the manifest. */
   root?: string;
-  /** Model id -> the path of its model manifest (a product manifest of live2d.model), relative to the site root. */
-  models?: Record<string, string>;
   [key: string]: unknown;
 }
 
 /** The story manifest format. */
-export const STORY_MANIFEST_FORMAT: "ournotes.story-manifest/2";
+export const STORY_MANIFEST_FORMAT: "nnnotes.product/1";
 /** The story manifest formats the player reads. */
-export const STORY_MANIFEST_FORMATS: readonly ["ournotes.story-manifest/2"];
+export const STORY_MANIFEST_FORMATS: readonly ["nnnotes.product/1"];
 
 /** Fetches a story manifest; refuses a story whose commands this player lacks. */
-export function fetchStoryManifest(url: string | URL, options?: { fetch?: typeof globalThis.fetch; signal?: AbortSignal | null }):
-  Promise<{ url: string; manifest: any }>;
+export function fetchStoryManifest(url: string | URL, options?: Pick<FromManifestOptions, "fetch" | "signal" | "base" | "decode">):
+  Promise<{ url: string; manifest: any; story: any; episode: any; root: string; fetch: typeof globalThis.fetch }>;
 
 export interface LoadStoryOptions extends FromManifestOptions {
   /** The language to load (default: the manifest's). */
   lang?: StoryLanguage | null;
   /** A manifest already fetched with fetchStoryManifest. */
-  manifest?: { url: string; manifest: any } | null;
+  manifest?: Awaited<ReturnType<typeof fetchStoryManifest>> | null;
 }
 
-/** The AssetStore of one language of a story: the manifest's common files and that language's files, the model.json
- *  of every model manifest it lists under live2d/<id>/ and their objects in one object table. `base` defaults to the
- *  manifest's `root`. */
+/** Load the story product and its scene, media, models, UI and fonts for one language into one object store. */
 export function loadStoryStore(url: string | URL, options?: LoadStoryOptions): Promise<AssetStore>;
 
 /** A talk log entry (AdvTalkHelper.AddLogEntry): Talk, Location, subtitles and chat rows, also those the shortcut