diff --git a/.cargo/config.toml b/.cargo/config.toml
index 9c57a99..100f9f5 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -7,3 +7,4 @@ rustflags = ["-C", "link-arg=-fuse-ld=mold"]
 [alias]
 clean-target = "run -p xtask --bin clean-target --"
 validate-levels = "run -p xtask --features validate-levels --bin validate-levels --"
+package-project = "run -p xtask --features validate-levels --bin package-project --"
diff --git a/.cursor/plans/animation_authoring_2026-07-11.plan.md b/.cursor/plans/animation_authoring_2026-07-11.plan.md
new file mode 100644
index 0000000..74f0834
--- /dev/null
+++ b/.cursor/plans/animation_authoring_2026-07-11.plan.md
@@ -0,0 +1,105 @@
+# Skeletal Animation Import, Preview, And Authoring
+
+Working implementation plan for Gitea issue
+[`#46`](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/46).
+This is the minimum production animation loop required by the M7 content-production milestone.
+
+## Status
+
+Implementation and production acceptance are complete. The persistent/runtime contract, generated
+manifest, stable model/clip identity, runtime adapter, browser drag workflow, typed inspector, and
+headless validation are implemented. Live acceptance covers import, placement, preview, scrub,
+save/reload hydration, PIE playback, source relocation, development packaging, and standalone
+runtime playback with the committed RobotExpressive fixture.
+
+## Outcome
+
+An author can import a supported skinned model, inspect its skeleton and clips, place an animated
+actor, preview and scrub a clip without dirtying the scene, save a small named state set, and drive
+the same state changes in PIE and a packaged game. Missing content and skeleton mismatches fail with
+owner-attributed repair guidance before packaging.
+
+## Format Policy
+
+- Animation authoring v1 supports glTF 2.0 (`.gltf` and `.glb`) through Bevy's native scene,
+  skinning, and animation assets.
+- FBX remains supported for the existing static mesh import path. An FBX containing animation stacks
+  or skin deformers is not a supported animated source and must produce a blocking, actionable
+  diagnostic.
+- Animated FBX support cannot be enabled until the loader constructs the source hierarchy, Bevy
+  skinned-mesh bindings, and `AnimationClip` assets. Metadata counts alone do not qualify as support.
+
+## Architecture
+
+- The asset registry UUID remains the parent model identity. A generated animation manifest under
+  `assets/animations/generated/` records the source fingerprint, skeleton signatures, stable clip
+  sub-asset IDs, clip metadata, and animation events.
+- `shared::AnimationControllerDesc` is reflected and serializable. It references imported skeletons
+  and clips through stable `EditorAssetRef` values and owns one layer of named states, a default
+  state, playback range/loop/speed, and default crossfade duration.
+- `game` owns the runtime adapter. It waits for the model `WorldAssetRoot` instance to become ready,
+  attaches transient animation graph/player state, and exposes a request API for changing an actor's
+  named state.
+- `editor` owns import presentation, clip/skeleton shelves, drag assignment/placement, inspector
+  controls, and non-dirty preview/scrubbing. Preview uses the runtime adapter rather than a separate
+  interpretation of the authored contract.
+- `scene` and package validation resolve the same manifests and stable references used by editor and
+  runtime hydration.
+
+## Authoritative Data
+
+The generated manifest is keyed by the model's stable registry UUID and includes:
+
+- schema version and source path/fingerprint;
+- scenes and exact skeleton signatures;
+- stable skeleton and clip sub-asset IDs;
+- clip label, source index, duration, target skeleton signature, and event markers;
+- import diagnostics, including unsupported animated FBX content.
+
+An exact skeleton signature is a deterministic hash of normalized ordered joint target paths and
+bind-pose structure. Retargeting v1 accepts only an exact signature match. No implicit joint-name,
+humanoid, or proportional remapping is allowed.
+
+## Implementation Sequence
+
+1. Add the versioned animation manifest schema, stable sub-asset identity rules, glTF extraction,
+   FBX blocking diagnostics, and focused importer tests.
+2. Add `AnimationControllerDesc`, named state/event types, registration, migration defaults,
+   actor validation, history snapshots, scene round-trip coverage, and runtime-only strip policy.
+3. Replace broad imported-model child cleanup with a dedicated generated instance root, then hydrate
+   the ready scene instance into a transient graph/player and implement the game state-request API.
+4. Extend Asset Browser model shelves with skeleton and clip rows, compatibility status, preview,
+   scrub/range/loop controls, and clip drag placement or assignment.
+5. Add the typed Animation Controller inspector, undoable state edits, PIE pause/stop reconciliation,
+   owner-attributed project validation, and package dependency collection.
+6. Commit a small redistributable animated GLB and sample scene, then run import, round-trip,
+   headless, live editor/PIE, and packaged-runtime acceptance.
+
+## Acceptance Gates
+
+- A committed skinned GLB and its clips import, preview, save, hydrate, and play in PIE and a
+  packaged runtime.
+- Moving or renaming the source inside the project preserves controller clip references through the
+  registry UUID and stable sub-asset IDs.
+- Missing manifests/clips and mismatched skeleton signatures produce actor/property-attributed
+  diagnostics with a concrete repair action.
+- Gameplay can request a valid named state through the public game API; invalid requests leave the
+  current state intact and report a diagnostic.
+- Preview follows the authored loop/range/speed settings, stops cleanly, and never mutates the scene
+  descriptor, history, or dirty state.
+- Generated graph/player/instance components never serialize into authored scenes, and model
+  rehydration never deletes authored hierarchy children.
+- Animated or skinned FBX content blocks animation import with a diagnostic that explains the glTF
+  v1 requirement.
+- Focused importer, validation, hydration, request-API, and editor operator tests pass alongside
+  workspace tests, `cargo validate-levels`, package validation, and live smoke testing.
+
+## Deliberate Boundaries
+
+- V1 provides one animation layer with named states, one default state, and a default crossfade. It
+  does not include a visual state graph, blend trees, transition-condition authoring, inverse
+  kinematics, motion matching, or root-motion extraction.
+- Event markers are normalized data and runtime notifications; V1 has no timeline scripting system.
+- Retargeting is exact signature match only.
+- FBX static mesh import remains available, but animated FBX conversion is separate loader work and
+  cannot silently fall back to bind-pose or metadata-only playback.
diff --git a/.cursor/plans/audio_authoring_2026-07-10.plan.md b/.cursor/plans/audio_authoring_2026-07-10.plan.md
new file mode 100644
index 0000000..69807ab
--- /dev/null
+++ b/.cursor/plans/audio_authoring_2026-07-10.plan.md
@@ -0,0 +1,72 @@
+# Audio Authoring And Runtime Parity
+
+Working implementation plan for Gitea issue
+[`#47`](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/47).
+This is the minimum complete audio loop required by the M7 content-production milestone.
+
+## Status
+
+Completed and production-accepted in Gitea #47. Permanent behavior is documented in
+[ADR 0030](../../docs/adr/0030-audio-authoring-and-bus-schema.md) and
+[Audio Authoring](../../docs/editor/audio-authoring.md).
+
+## Outcome
+
+An author can import a supported audio clip, place or assign it as an authored source, tune playback
+and spatial behavior, audition it without dirtying the scene, save/reload it, and hear equivalent
+behavior in PIE and a packaged game. Projects expose stable Master, Music, and SFX buses with runtime
+gain/mute hooks and validation that also runs headlessly.
+
+## Architecture
+
+- `shared` owns reflected, serializable source/listener/attenuation descriptors and stable actor kinds.
+- `settings` owns versioned project bus definitions and validation; bus references use stable IDs.
+- `game` hydrates authoring descriptors into Bevy audio playback/listener components and applies bus
+  controls. Hydrated components remain derived and are never scene source of truth.
+- `editor` owns asset discovery/import UX, inspector controls, drag/drop placement, visualizers, and
+  transient audition state. Audition never mutates an authored descriptor or marks a scene dirty.
+- Scene and project validation share the same clip-reference, bus-reference, range, and listener rules
+  used by packaging. Missing, excluded, unsupported, or Git LFS pointer clips block release validation.
+
+## Supported Content
+
+- Ogg Vorbis is the baseline runtime format.
+- WAV, MP3, and FLAC support is enabled explicitly in the workspace Bevy feature set.
+- Audio sources support gain, pitch, looping, autoplay, spatial blend, attenuation, and bus routing.
+- Listener authoring supports enabled state, priority, and ear gap; at runtime exactly one enabled
+  listener is selected deterministically.
+- Default project buses are `master`, `music`, and `sfx`; Music and SFX route to Master.
+
+## Implementation Sequence
+
+1. Add shared descriptors, settings schema/defaults/validation, launcher scaffolding, and migrations.
+2. Add audio clip catalog classification, import target, search/filter/details, and drag payloads.
+3. Add runtime source/listener hydration, deterministic listener selection, and bus controls.
+4. Add inspector cards with undoable edits and scene save/validation allowlists.
+5. Add viewport icons/range visualizers and transient audition/stop using the editor camera listener.
+6. Add a small sample clip/scene, focused round-trip and PIE tests, live QA, permanent docs, and Gitea
+   acceptance evidence.
+
+## Acceptance Gates
+
+- Dragging a clip into the viewport creates an audio source; dropping onto a compatible selected
+  source assigns the clip through one undoable command.
+- Inspector edits survive save/reload and PIE hydration without generated playback state leaking into
+  the authored scene.
+- Spatial preview follows the editor camera, stops on explicit Stop, mode/project changes, or source
+  deletion, and never changes scene dirty state.
+- Bus definitions persist with stable IDs, invalid parent cycles/references are rejected, and runtime
+  gain/mute hooks affect routed sources.
+- Headless validation reports missing/unpackageable clips, unsupported values, invalid buses, and
+  ambiguous enabled listeners with actor/property context.
+- Focused unit/integration tests, `cargo validate-levels`, package validation, and live editor/game
+  smoke tests passed for issue `#47` closure.
+
+## Deliberate Boundaries
+
+- This slice does not include DSP graphs, reverb zones, waveform editing, audio streaming banks,
+  middleware integration, or platform-specific compression pipelines.
+- Continuous spatial blend is represented authoritatively and implemented without claiming Bevy
+  supports a native blend control; the runtime adapter owns the mapping/mix behavior.
+- A future mixer UI may expose additional buses and sends, but it must preserve the stable bus IDs and
+  parent graph established here.
diff --git a/.cursor/plans/blacksite_production_readiness_2026-07-10.plan.md b/.cursor/plans/blacksite_production_readiness_2026-07-10.plan.md
new file mode 100644
index 0000000..fc1005c
--- /dev/null
+++ b/.cursor/plans/blacksite_production_readiness_2026-07-10.plan.md
@@ -0,0 +1,101 @@
+# Blacksite Editor Production Readiness Program
+
+Working milestone plan for the production expansion tracked by Gitea epic
+[`#1`](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/1).
+The existing Jackdaw-inspired M0-M5 roadmap remains the authoring/tool foundation. This plan adds
+the reliability and shipping gates required for daily indie game production.
+
+## Definition Of Production Ready
+
+Blacksite is production ready only when the evidence matrix in Gitea
+[`#50`](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/50)
+is signed off. Feature presence alone is insufficient. Recovery, validation, packaging,
+performance, soak, regression, and first-hour workflows must pass against a representative project.
+
+## Immediate Sequence
+
+1. Completed: hierarchy/prefab boundary hardening `#40`, transactional recovery `#39`, stable
+   sessions/diagnostics `#41`, and Project Browser/startup boundaries `#3`.
+2. Completed: stable scene tabs and composed subscene ownership/validation in `#42`.
+3. Completed: nested prefabs, variants, and structural overrides passed production acceptance in
+   `#43`; M6 implementation is complete.
+4. Completed: authoritative content validation `#45` and the validation-gated packaging/Build
+   workflow `#44`.
+5. Completed: audio source/listener/bus authoring and spatial preview passed production acceptance
+   in `#47`. Next: animation `#46`, navigation `#48`, source-control safety `#49`, then readiness
+   gate `#50`.
+
+## M6 - Reliability, Recovery, And Project Workflow
+
+**Exit:** A normal or interrupted editor session cannot silently lose or corrupt authored work, and
+projects/scenes/prefabs have stable daily workflows.
+
+| Issue | Capability | Priority |
+|-------|------------|----------|
+| #3 | Project launcher, templates, recent projects, resume | P0 |
+| #39 | Transactional saves, autosave, crash recovery | P0 |
+| #40 | Hierarchy, parenting, prefab structure hardening | P0 |
+| #41 | Session persistence and crash diagnostics | P0 |
+| #42 | Multi-scene tabs, subscenes, level composition | P1 |
+| #43 | Nested prefabs, variants, structural overrides | P1 |
+
+## M7 - Content Production And Shipping
+
+**Exit:** A clean checkout can validate, build, package, and run a representative project with the
+minimum animation, audio, and navigation authoring loops required by the game.
+
+| Issue | Capability | Priority |
+|-------|------------|----------|
+| #44 | Build/package profiles and Build panel | P0 |
+| #45 | Dependency manifest and content release gate | P0 |
+| #46 | Skeletal animation import/preview/authoring | P1 |
+| #47 | Audio sources/listeners/buses/spatial preview | P1 |
+| #48 | Navigation authoring/bake/path preview | P1 |
+| #49 | Source-control status and collaborative file safety | P2 |
+| #50 | Production-readiness acceptance matrix | P0 |
+
+## Cross-Cutting Gates
+
+- Authored IDs, scene schema, hydration stripping, and extension boundaries remain authoritative.
+- Every mutation supports meaningful undo/redo; modal tools also support cancel without dirty state.
+- Editor-only helpers, recovery files, and caches never enter scenes or game packages.
+- Interactive and headless validation use the same rules and produce equivalent blocking results.
+- Large asset, terrain, navigation, and geometry work is debounced or dirty-region based.
+- Visible behavior updates root controls and `docs/editor/`; hard-to-reverse decisions get ADRs.
+- Production signoff requires a second-person first-hour QA pass and no open P0 blocker.
+
+## Completed Slice - UI Identity And Structural Dragging
+
+- Near-black Blacksite shell with compact tool identity rather than a Unity clone.
+- Pointer-following asset drag preview, viewport reticle, boundary, and corner brackets.
+- Full-width hierarchy attach targets plus explicit root/reorder/invalid feedback.
+- World-transform-preserving reparent/unparent with grouped history.
+- Cycle rejection, subtree-safe multi-drag, parent expansion, and focused regression coverage.
+
+## Completed Slice - Multi-Scene Production Workflow
+
+- Independent scene tabs integrated into the right end of the existing main toolbar.
+- Stable `SceneComposition` resources with project-relative references and no runtime entity IDs.
+- Recursive missing/cycle/duplicate/path-escape validation shared by editor and CI.
+- Runtime-only composed ownership, load/lock/focus controls, and owner-save exclusion.
+- Per-saved-tab recovery, composition undo/redo, PIE-active composition consistency, and fixtures.
+
+## Completed Slice - Validation-Gated Build And Packaging
+
+- Shared owner-attributed project validation and runtime-packageability policy in editor, CI, and
+  packaging; unknown schemas, missing LFS objects, excluded references, and unsafe traversal block.
+- Versioned development/QA/release profiles with Cargo-reported artifacts, rendering/default-scene
+  application, Windows QA symbols, supported-target enforcement, and deterministic metadata.
+- OS-locked authenticated staging, interrupted-build recovery, complete pre-publish hashing, safe
+  replacement, and unchanged-output reuse.
+- Non-blocking editor Build/Run/Cancel/Reveal workflow with dirty-tab guard and process-tree cleanup.
+- Gitea #44 and #45 closed after headless, focused regression, repeated-build, and live packaged
+  development-runtime acceptance.
+
+## Completed Slice - Audio Authoring And Spatial Preview
+
+The stable authoring/runtime contract is recorded in
+[ADR 0030](../../docs/adr/0030-audio-authoring-and-bus-schema.md), with controls, runtime behavior,
+validation, and the committed sample fixture documented in
+[Audio Authoring](../../docs/editor/audio-authoring.md). Gitea #47 closed after automated,
+headless, live editor/PIE, and packaged-runtime acceptance.
diff --git a/.gitignore b/.gitignore
index 4cbe9e4..83d8053 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 # Rust build output
 /target/
+/dist/
 
 # Local automation and assistant state
 /.agents/
diff --git a/.vscode/launch.json b/.vscode/launch.json
index ac2b63f..bd081d5 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -111,6 +111,27 @@
       "sourceLanguages": ["rust"],
       "gracefulShutdown": "SIGINT"
     },
+    {
+      "type": "lldb",
+      "request": "launch",
+      "name": "Editor: Project root...",
+      "cargo": {
+        "args": ["build", "-p", "editor", "--bin", "editor", "--features", "dev"],
+        "filter": { "name": "editor", "kind": "bin" },
+        "env": { "CARGO_TARGET_DIR": "${workspaceFolder}/target" },
+        "problemMatcher": "$rustc"
+      },
+      "args": ["--project", "${input:blacksiteProjectRoot}"],
+      "env": {
+        "RUST_BACKTRACE": "1",
+        "WGPU_VALIDATION": "0",
+        "LD_LIBRARY_PATH": "${workspaceFolder}/target/debug/deps:${env:LD_LIBRARY_PATH}"
+      },
+      "cwd": "${workspaceFolder}",
+      "terminal": "integrated",
+      "sourceLanguages": ["rust"],
+      "gracefulShutdown": "SIGINT"
+    },
     {
       "type": "lldb",
       "request": "launch",
@@ -221,5 +242,13 @@
       "sourceLanguages": ["rust"],
       "gracefulShutdown": "SIGINT"
     }
+  ],
+  "inputs": [
+    {
+      "id": "blacksiteProjectRoot",
+      "type": "promptString",
+      "description": "Absolute path to a Blacksite project root",
+      "default": "${workspaceFolder}"
+    }
   ]
 }
diff --git a/Cargo.lock b/Cargo.lock
index e58c263..57c8a65 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -403,7 +403,7 @@ dependencies = [
  "bevy_math",
  "bevy_transform_interpolation",
  "bitflags 2.13.0",
- "derive_more",
+ "derive_more 2.1.1",
  "disqualified",
  "glam_matrix_extras",
  "itertools 0.15.0",
@@ -550,7 +550,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "blake3",
- "derive_more",
+ "derive_more 2.1.1",
  "downcast-rs 2.0.2",
  "either",
  "petgraph",
@@ -642,7 +642,7 @@ dependencies = [
  "bitflags 2.13.0",
  "blake3",
  "crossbeam-channel",
- "derive_more",
+ "derive_more 2.1.1",
  "disqualified",
  "downcast-rs 2.0.2",
  "either",
@@ -707,7 +707,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "derive_more",
+ "derive_more 2.1.1",
  "downcast-rs 2.0.2",
  "serde",
  "smallvec",
@@ -739,7 +739,7 @@ dependencies = [
  "bevy_math",
  "bevy_reflect",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "encase",
  "serde",
  "thiserror 2.0.18",
@@ -866,7 +866,7 @@ dependencies = [
  "bitflags 2.13.0",
  "bumpalo",
  "concurrent-queue",
- "derive_more",
+ "derive_more 2.1.1",
  "fixedbitset",
  "indexmap",
  "log",
@@ -1160,7 +1160,7 @@ dependencies = [
  "bevy_math",
  "bevy_platform",
  "bevy_reflect",
- "derive_more",
+ "derive_more 2.1.1",
  "log",
  "serde",
  "smol_str",
@@ -1343,7 +1343,7 @@ dependencies = [
  "approx",
  "arrayvec",
  "bevy_reflect",
- "derive_more",
+ "derive_more 2.1.1",
  "glam 0.32.1",
  "itertools 0.14.0",
  "libm",
@@ -1372,7 +1372,7 @@ dependencies = [
  "bevy_transform",
  "bitflags 2.13.0",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "encase",
  "glam 0.32.1",
  "half",
@@ -1420,7 +1420,7 @@ dependencies = [
  "bevy_utils",
  "bitflags 2.13.0",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "fixedbitset",
  "indexmap",
  "nonmax",
@@ -1521,7 +1521,7 @@ dependencies = [
  "bevy_ptr",
  "bevy_reflect_derive",
  "bevy_utils",
- "derive_more",
+ "derive_more 2.1.1",
  "disqualified",
  "downcast-rs 2.0.2",
  "erased-serde",
@@ -1613,7 +1613,7 @@ dependencies = [
  "bevy_window",
  "bitflags 2.13.0",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "downcast-rs 2.0.2",
  "encase",
  "glam 0.32.1",
@@ -1726,7 +1726,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "tracing",
 ]
 
@@ -1783,7 +1783,7 @@ dependencies = [
  "bevy_utils",
  "bitflags 2.13.0",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "fixedbitset",
  "nonmax",
  "tracing",
@@ -1829,7 +1829,7 @@ dependencies = [
  "bevy_platform",
  "concurrent-queue",
  "crossbeam-queue",
- "derive_more",
+ "derive_more 2.1.1",
  "futures-lite",
  "heapless 0.9.3",
  "web-task",
@@ -1891,7 +1891,7 @@ dependencies = [
  "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
- "derive_more",
+ "derive_more 2.1.1",
  "serde",
  "thiserror 2.0.18",
 ]
@@ -1946,7 +1946,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "derive_more",
+ "derive_more 2.1.1",
  "parley",
  "serde",
  "smallvec",
@@ -1985,7 +1985,7 @@ dependencies = [
  "bevy_ui",
  "bevy_utils",
  "bytemuck",
- "derive_more",
+ "derive_more 2.1.1",
  "indexmap",
  "tracing",
 ]
@@ -2094,7 +2094,7 @@ dependencies = [
  "bevy_reflect",
  "bevy_transform",
  "bevy_utils",
- "derive_more",
+ "derive_more 2.1.1",
  "ron 0.12.1",
  "serde",
  "thiserror 2.0.18",
@@ -2390,6 +2390,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
 
+[[package]]
+name = "claxon"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bfbf56724aa9eca8afa4fcfadeb479e722935bb2a0900c2d37e0cc477af0688"
+
 [[package]]
 name = "clipboard-win"
 version = "5.4.1"
@@ -2466,6 +2472,27 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32b13ea120a812beba79e34316b3942a857c86ec1593cb34f27bb28272ce2cca"
 
+[[package]]
+name = "const_format"
+version = "0.2.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4481a617ad9a412be3b97c5d403fef8ed023103368908b9c50af598ff467cc1e"
+dependencies = [
+ "const_format_proc_macros",
+ "konst",
+]
+
+[[package]]
+name = "const_format_proc_macros"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
 [[package]]
 name = "const_panic"
 version = "0.2.15"
@@ -2496,6 +2523,12 @@ dependencies = [
  "const_soft_float",
 ]
 
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
 [[package]]
 name = "convert_case"
 version = "0.10.0"
@@ -2780,6 +2813,19 @@ version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
 
+[[package]]
+name = "derive_more"
+version = "0.99.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
+dependencies = [
+ "convert_case 0.4.0",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+]
+
 [[package]]
 name = "derive_more"
 version = "2.1.1"
@@ -2795,7 +2841,7 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
 dependencies = [
- "convert_case",
+ "convert_case 0.10.0",
  "proc-macro2",
  "quote",
  "rustc_version",
@@ -2906,6 +2952,7 @@ dependencies = [
  "bevy_egui",
  "bevy_solari",
  "bevy_ufbx",
+ "blake3",
  "egui_dock",
  "egui_phosphor_icons",
  "game",
@@ -2918,6 +2965,7 @@ dependencies = [
  "ron 0.8.1",
  "scene",
  "serde",
+ "serde_json",
  "settings",
  "shared",
  "sim",
@@ -3024,6 +3072,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "enum_dispatch"
 version = "0.3.13"
@@ -3398,9 +3455,13 @@ dependencies = [
  "avian3d",
  "bevy",
  "bevy_ufbx",
+ "cpal",
  "game_hot",
  "hot-lib-reloader",
  "protocol",
+ "ron 0.12.1",
+ "scene",
+ "serde",
  "settings",
  "shared",
  "sim",
@@ -3801,6 +3862,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "hound"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62adaabb884c94955b19907d60019f4e145d091c75345379e70d1ee696f7854f"
+
 [[package]]
 name = "http"
 version = "1.4.2"
@@ -4250,6 +4317,21 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
+[[package]]
+name = "konst"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "128133ed7824fcd73d6e7b17957c5eb7bacb885649bd8c69708b2331a10bcefb"
+dependencies = [
+ "konst_macro_rules",
+]
+
+[[package]]
+name = "konst_macro_rules"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37"
+
 [[package]]
 name = "kqueue"
 version = "1.2.0"
@@ -4406,6 +4488,22 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "macro_rules_attribute"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf0c9b980bf4f3a37fd7b1c066941dd1b1d0152ce6ee6e8fe8c49b9f6810d862"
+dependencies = [
+ "macro_rules_attribute-proc_macro",
+ "paste",
+]
+
+[[package]]
+name = "macro_rules_attribute-proc_macro"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58093314a45e00c77d5c508f76e77c3396afbbc0d01506e7fae47b018bac2b1d"
+
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -4430,6 +4528,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -4566,6 +4670,16 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
 
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "nonmax"
 version = "0.5.5"
@@ -5807,10 +5921,13 @@ version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a536bb79db59098ef71a4dd4246c02eb87b316deceb1b68e0cde7167ec01eb"
 dependencies = [
+ "claxon",
  "cpal",
  "dasp_sample",
+ "hound",
  "lewton",
  "num-rational",
+ "symphonia",
  "thiserror 2.0.18",
  "tracing",
 ]
@@ -5841,6 +5958,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "ron-edit"
+version = "0.2.0"
+dependencies = [
+ "const_format",
+ "derive_more 0.99.20",
+ "macro_rules_attribute",
+ "nom",
+ "unicode-ident",
+]
+
 [[package]]
 name = "rstar"
 version = "0.12.2"
@@ -5930,8 +6058,11 @@ dependencies = [
 name = "scene"
 version = "0.1.0"
 dependencies = [
+ "blake3",
  "ron 0.8.1",
+ "ron-edit",
  "serde",
+ "settings",
  "shared",
 ]
 
@@ -6315,6 +6446,55 @@ dependencies = [
  "zeno",
 ]
 
+[[package]]
+name = "symphonia"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039"
+dependencies = [
+ "lazy_static",
+ "symphonia-bundle-mp3",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-core"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af"
+dependencies = [
+ "arrayvec",
+ "bitflags 1.3.2",
+ "bytemuck",
+ "lazy_static",
+ "log",
+]
+
+[[package]]
+name = "symphonia-metadata"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.118"
@@ -7881,7 +8061,13 @@ checksum = "3ae8337f8a065cfc972643663ea4279e04e7256de865aa66fe25cec5fb912d3f"
 name = "xtask"
 version = "0.1.0"
 dependencies = [
+ "blake3",
+ "libc",
+ "ron 0.8.1",
  "scene",
+ "serde",
+ "serde_json",
+ "settings",
  "walkdir",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 1f2960a..72a7607 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,14 @@ avian3d = { version = "0.7", default-features = false, features = [
     "collider-from-mesh",
     "serialize",
 ] }
-bevy = { version = "0.19", features = ["serialize", "jpeg"] }
+bevy = { version = "0.19", features = [
+    "serialize",
+    "jpeg",
+    "vorbis",
+    "wav",
+    "mp3",
+    "flac",
+] }
 bevy_core_pipeline = "0.19"
 bevy_solari = "0.19"
 bevy_ufbx = "0.18.1-rc.1"
@@ -47,6 +54,8 @@ scene = { path = "crates/scene" }
 [patch.crates-io]
 # Local Bevy 0.19 compatibility patch until upstream publishes a matching FBX loader.
 bevy_ufbx = { path = "third_party/bevy_ufbx" }
+# Lossless RON editing fixes used by transactional prefab source edits.
+ron-edit = { path = "third_party/ron-edit" }
 # Atmosphere-aware mesh view bind groups (WYSIWYG editor + transform gizmos).
 transform-gizmo-bevy = { path = "third_party/transform-gizmo-bevy" }
 
@@ -73,3 +82,19 @@ opt-level = 3
 [profile.release]
 lto = "thin"
 codegen-units = 1
+strip = "symbols"
+
+# Export profiles keep runtime optimization and compact binaries without forcing
+# release LTO into normal editor iteration.
+[profile.package-dev]
+inherits = "release"
+lto = false
+codegen-units = 16
+strip = "symbols"
+
+[profile.package-qa]
+inherits = "release"
+lto = false
+codegen-units = 8
+debug = "line-tables-only"
+strip = "none"
diff --git a/README.md b/README.md
index 63b6f8f..5b98f53 100644
--- a/README.md
+++ b/README.md
@@ -27,6 +27,9 @@ cargo clippy --workspace --all-targets -- -D warnings
 cargo clippy -p editor -p game --bins --features dev,hot-reload -- -D warnings
 cargo test --workspace
 cargo validate-levels
+# Machine-readable project dependency and finding report
+cargo validate-levels --json
+cargo package-project --profile development
 
 # Runtime game
 cargo run -p game
@@ -37,6 +40,22 @@ cargo run -p editor
 cargo run -p editor --features dev
 ```
 
+The standalone `game` binary loads `default_level` from `assets/project.ron` as the initial authored
+scene. That entrypoint must be a regular `.scn.ron` file under `assets/levels/` so validation audits
+its complete runtime dependency graph. The in-process editor defers that bootstrap to its scene tabs
+and `SceneIo`, so opening the editor never creates a competing runtime scene root.
+
+Open a different validated Blacksite project before engine startup:
+
+```bash
+cargo run -p editor --features dev -- --project /path/to/project
+cargo run -p editor --bin project_launcher --features dev
+```
+
+The installed **Blacksite Editor** desktop entry also exposes **Open Project Browser** from its
+desktop action menu. In the editor, **File > Switch Project...** performs a clean shutdown and
+opens the same browser; choosing a project starts a fresh editor process with that root.
+
 ### Hot reload (gameplay iteration)
 
 `--features dev` turns on Bevy **dynamic linking** for faster rebuilds (recommended day-to-day).
@@ -82,7 +101,7 @@ rebuild caused by `cargo clean`. The workspace test profile keeps line tables bu
 debuginfo and incremental test caches, so routine test binaries stay materially smaller without
 reducing normal editor debugging fidelity. The cleanup binary deliberately excludes the scene/Bevy
 validation dependency; `cargo clean-target` therefore stays cheap even from a cold target. Use
-`cargo validate-levels` when scene validation is required. VS Code tasks expose dry-run, safe, and
+`cargo validate-levels` when level and prefab-graph validation is required. VS Code tasks expose dry-run, safe, and
 deep-stale variants.
 
 ### Launch Troubleshooting
@@ -115,27 +134,35 @@ deep-stale variants.
 | `Ctrl+D` | Duplicate selection |
 | `Ctrl+Z` / `Ctrl+Shift+Z` / `Ctrl+Y` | Undo / redo |
 | `F2` in Hierarchy | Rename selection |
-| `W` / `E` / `R` | Translate / rotate / scale gizmo |
+| `W` / `E` / `R` | Translate / rotate / scale gizmo; multi-selection uses one grouped gizmo and undo step |
 | `X` | Toggle world/local gizmo orientation |
 | `B` | Enter Draw Brush mode |
 | Draw Brush: LMB / `Enter` / mouse up-down / `Esc` / `Backspace` | Place floor points / enter height phase or create / set height / cancel / remove point or return to outline |
 | Brush selected: `1` / `2` / `3` / `4` | Vertex / edge / face / clip edit modes |
 | Brush edit mode: LMB / `Shift+LMB` / `W` / `E` / `R` / `Esc` | Select element / toggle element selection / move / rotate / scale selected brush elements / return to object mode |
 | Viewport toolbar (sun / brush / box icons) | Shading: Lit, Unlit (albedo), Colliders (mesh off) |
-| Viewport eye/options | Toggle actor root icon categories, adjust icon/gizmo size, and control colliders, lights, spawns, prefab/model anchors, and runtime player/camera visualizers |
+| Viewport eye/options | Toggle actor root icon categories, adjust icon/gizmo size, and control colliders, lights, spawns, gameplay markers, volumes, prefab/model anchors, and runtime player/camera visualizers |
 | `Tab` in viewport | Cycle selection through overlapping objects at last click |
+| Viewport selection/orientation HUD | Identify the primary selection, multi-selection count, overlapping-pick position, camera axes, shading mode, and active render path |
 | Click Player visualizer in Edit mode | Select or create the authored `PlayerSpawn` (`Player Start`) |
 | Select Project Sun | Inspect project default lighting; create a scene sun override |
-| Asset Browser project/file views | Browse `assets/`, search/filter/sort, switch grid/list, expand model subassets with generated thumbnails, inspect staged import/material settings, drag assets/submeshes into the viewport |
+| Asset Browser project/file views | Browse `assets/`, search/filter/sort models, textures, materials, audio clips, levels, and prefabs; switch grid/list; expand model subassets; inspect file details; audition audio; drag supported assets/submeshes into the viewport |
+| Drag audio clip into viewport | Create an authored audio source; when an audio source is selected, assign the clip instead |
 | Asset Browser context/details actions | Apply textures/materials, regenerate thumbnails, reimport models, place assets/submeshes, or move file assets to `assets/.trash/` |
 | `Ctrl+P` | Centered command palette; search human labels or stable command IDs, use arrow keys to select, Enter to run |
 | `F7` | While paused in Play: advance one sim tick |
 | Shift/Ctrl + click (Hierarchy) | Additive selection |
-| Hierarchy context | Reparent to other selection / Unparent |
-| File menu | New, Open, Save, Save As, Import Assets, Export Selection, Save Selection As Prefab, Recent Scenes |
+| Drag actor row onto another actor (Hierarchy) | Attach/reparent while preserving world placement; multi-selection keeps existing subtrees and commits one undo step |
+| Drag actor between rows / onto Scene Root (Hierarchy, Manual sort) | Reorder siblings / unparent to the root |
+| Hierarchy lock | Excludes the actor from selection, gizmos, multi-drag, structural drops, and mutating context actions |
+| Hierarchy context | Group selection, create authored local children below linked prefab roots, remove/reparent generated members through same-layer structural overrides, or unparent |
+| File menu | New, Open, transactional Save/Save As, recovery restore/keep-copy/discard when available, Import Assets, Export Selection, Save Selection As Prefab (including linked-root variants), Recent Scenes |
+| Main toolbar, right side | Switch or close independent scene tabs, create an untitled tab, and manage loaded/locked composed subscenes |
+| Prefab Instance inspector | Inspect/recover source health, Apply/Revert overrides by scope, Apply overrides to source, create a variant, **Unpack Layer**, or recursively **Convert to Local** |
 | Inspector component card | Collapse with caret, toggle active with status dot, or use triple-dot menu for reset/copy/paste/move/remove actions |
 | Inspector footer → Add Component | Expands an inline search shelf for registered authoring, rendering, physics, gameplay, and volume components with descriptions, availability hints, and undo |
-| Edit → Project Settings… | Edit `assets/project.ron` (rendering, physics, input) |
+| Audio Source / Listener inspector | Assign and audition clips; edit gain, pitch, loop/autoplay, spatial blend, attenuation, bus, listener priority, and ear gap |
+| Edit → Project Settings… | Edit `assets/project.ron` rendering, audio buses, physics, and input |
 
 Viewport shortcut keys require the pointer to be in the viewport and are suspended while typing in egui text fields or actively using camera navigation. `Delete`, `Backspace`, duplicate, and undo/redo also defer to text-field focus.
 
@@ -175,7 +202,18 @@ Viewport shortcut keys require the pointer to be in the viewport and are suspend
 ## Scene Workflow
 
 - Levels are saved as native Bevy dynamic scenes under `assets/levels/`.
+- Scene tabs live at the right end of the existing main toolbar. Open creates another tab; each tab
+  retains its own path and dirty state, and close prompts only for that document.
+- The adjacent **Composition** menu adds validated project-relative subscenes, loads/unloads them,
+  applies read-only hierarchy locks, and focuses their actors. Recursive validation rejects missing
+  or cyclic references before replacing the active world. See
+  [multi-scene-composition.md](docs/editor/multi-scene-composition.md).
 - Editable entities use reflectable authoring components from `crates/shared`.
+- Linked prefabs keep source-generated actors out of owner-scene serialization through runtime
+  `HydratedPrefabMember` ownership. Generated actor properties/components and same-layer structural
+  changes use stable nested override paths; authored local children and nested linked instances can
+  live below an instance root. Saving that linked root and its local hierarchy as a prefab creates
+  the current variant representation. See [prefab-authoring.md](docs/editor/prefab-authoring.md).
 - The editable player start is an authored `PlayerSpawn`; moving it with the transform gizmo changes
   where Play mode boots the runtime player.
 - Project settings provide default ambient/sun lighting. A scene-authored directional `LightDesc`
@@ -189,9 +227,13 @@ Viewport shortcut keys require the pointer to be in the viewport and are suspend
   artifacts in `assets/meshes/generated/`. Renderer slots reference imported content-browser mesh
   and material assets, while generated collision is stored separately in `ColliderDesc` plus
   `RigidBodyDesc`. Switch a model asset's placement mode to **Scene Instance** in Asset Browser
-  details when you need full `WorldAssetRoot` loading for animation/skinning/scene data. Expanding a
-  model in the Asset Browser exposes normalized mesh/material/texture subassets; dragging a mesh
-  subasset places that part through the same static mesh renderer path.
+  details when you need full `WorldAssetRoot` scene data instead of normalized static slots.
+  Expanding a model in the Asset Browser exposes normalized mesh/material/texture plus generated
+  skeleton/animation-clip subassets. Dragging a mesh places that part through the static mesh path;
+  dragging a clip creates an animated scene instance or assigns an exact-rig-compatible state to
+  the selected imported model. The Animation Controller inspector edits state IDs, clips,
+  range/loop/speed/default/crossfade and provides non-dirty play/pause/stop/scrub preview. See the
+  [animation authoring guide](docs/editor/animation-authoring.md) and [ADR 0031](docs/adr/0031-animation-authoring-runtime-contract.md).
 - Brush actors are persisted as `ActorKind::Brush + BrushDesc`; valid convex faces hydrate into
   generated preview meshes. Vertex, edge, and face selections use the standard transform gizmo,
   face material/UV fields are undoable, and clip/intersect/merge/subtract provide conservative
@@ -229,7 +271,41 @@ Viewport shortcut keys require the pointer to be in the viewport and are suspend
 
 ### Hierarchy scrolls during drag
 
-Scroll-to-drag is disabled while dragging actors. Release the mouse to finish or cancel the drag.
+Scroll-to-drag is disabled while dragging actors. The pointer card reports the pending action:
+drop on a full actor row to attach, on the **Scene Root** zone to unparent, or between rows in
+**Manual** sort to reorder. Amber means attach, cyan means reorder/root, and red blocks a hierarchy
+cycle. Release away from a valid target to cancel.
+
+### Scene recovery
+
+Dirty saved scenes create a recovery snapshot every 120 seconds and retain the newest five
+generations under `$XDG_STATE_HOME/blacksite-editor/recovery` or
+`~/.local/state/blacksite-editor/recovery`. If a snapshot is newer than the authored scene, the
+status strip shows `[recovery]` and recovery actions become available in **File**. **Restore
+Recovery Snapshot** loads it into dirty editor state for inspection, **Save Recovery Copy As...**
+writes a separate transactional scene copy without changing the active scene, and **Discard
+Recovery Snapshot** retires all generations. Restore keeps the generation available until **Save**
+commits the active scene or discard explicitly retires it. The **Diagnostics** window retains the
+latest 32 scene I/O results, including exact recovery paths and failures, for the current session.
+Unsaved new scenes are not yet covered by automatic recovery.
+For recovery testing only, `BLACKSITE_RECOVERY_INTERVAL_SECS=<seconds>` overrides the interval for
+the current process without changing preferences.
+
+### Session recovery
+
+Clean editor exits restore the last authored scene, panel visibility, and viewport bookmarks from
+the versioned machine-local session document. After an abnormal exit, Blacksite opens the safe
+startup scene and asks whether to **Resume Last Scene** or **Continue Safe**; modal tools and dirty
+preview state are never restored. Session metadata lives under
+`$XDG_STATE_HOME/blacksite-editor/session.ron` or `~/.local/state/blacksite-editor/session.ron` and
+contains no scene contents or credentials. See [ADR 0024](docs/adr/0024-versioned-editor-session-state.md).
+
+Open **Window → Diagnostics** and choose **Export Diagnostic Bundle** to write a transactional
+support report under `$XDG_STATE_HOME/blacksite-editor/diagnostics` or
+`~/.local/state/blacksite-editor/diagnostics`. The report includes build/platform and renderer
+identity, project and active-scene paths, dirty flags, aggregate validation counts, prior-crash
+state, and the bounded Scene I/O log. It excludes scene and asset contents, environment values,
+host/user identity, credentials, access tokens, and modal tool state.
 
 ## Cursor / VSCode Setup
 
@@ -292,11 +368,17 @@ crates/
 - [x] CI workflow for format, check, clippy, tests, and binary builds
 - [x] ADRs for roadmap architecture and Bevy migration policy
 - [x] Determinism harness: same inputs over same ticks produce the same state summary/hash
+- [x] Reusable editor operator harness for commit/cancel/block, helper cleanup, dirty state, grouped undo, and undo/redo round trips
 - [x] Verify: `cargo fmt --check` / `cargo check --workspace` / `cargo clippy --workspace` / strict foundation clippy / `cargo test -p sim`
 - [x] Stable asset registry with UUIDs + import settings in asset browser details
 - [x] Asset Browser expandable model subasset shelves, independent mesh/material/texture thumbnails, staged import/material details with shader-schema parameters, context actions, and trash-first file removal
+- [x] Audio clip catalog/import foundation for Ogg, WAV, MP3, and FLAC with dedicated filtering, file details, and stable runtime-resolvable asset references
+- [x] Audio source/listener authoring, non-dirty spatial audition, viewport icons/range gizmos, stable buses, PIE/runtime parity, device diagnostics, and shared release validation ([ADR 0030](docs/adr/0030-audio-authoring-and-bus-schema.md); production acceptance completed in [Gitea #47](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/47))
+- [x] glTF/GLB skeletal animation manifests, stable controller states, non-dirty preview, PIE/runtime hydration, and exact-signature compatibility validation ([ADR 0031](docs/adr/0031-animation-authoring-runtime-contract.md); production acceptance completed in [Gitea #46](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/46))
 - [x] Prefab instances (`PrefabInstance`) + save-as-prefab + unpack
-- [x] Unsaved-scene confirm on New/Open/Recent
+- [x] Independent dirty-tab close confirmation and all-tab save guard when switching projects
+- [x] Transactional scene writes + bounded user-local recovery snapshots ([ADR 0023](docs/adr/0023-transactional-scene-persistence-and-recovery.md))
+- [x] Versioned clean/crash session resume + privacy-bounded diagnostic bundle ([ADR 0024](docs/adr/0024-versioned-editor-session-state.md))
 - [x] Hierarchy multi-select, reparent undo, multi-entity gizmo transform
 - [x] Typed inspector undo (light, rigid body, collider, primitive, material, static mesh renderer) + registry-driven Add Component footer
 - [x] Gameplay authoring markers + visualizers (`WeaponSpawn`, `TriggerVolume`, etc.)
@@ -305,14 +387,18 @@ crates/
 - [x] `ActorInspectorSection` registry + game demo section (`game::editor_ext`)
 - [x] Command palette: reset lighting, group selection, focus selection
 - [x] CI: `cargo test -p shared`, scene authoring-only check on repo level, `cargo check -p editor --features dev`
-- [x] `scene` crate schema stamp/migrate/validate on save/load + CI `validate-levels`
+- [x] `scene` crate schema stamp/migrate/validate on save/load + CI `validate-levels` for levels and prefab graphs
 - [x] Project Settings draft + Apply (HDR/swapchain safe)
-- [ ] Project launcher/scaffolding with startup-time asset-root selection; the unsafe in-process File → Project scaffold was removed pending BS-JD-001
+- [x] Project Browser UI, strict manifest validation, `--project` startup activation, recent filtering, sandbox scaffolding, clean process handoff, and desktop launcher action ([ADR 0025](docs/adr/0025-project-root-is-a-startup-boundary.md))
+- [x] Independent scene tabs + stable subscene composition, recursive validation, ownership locks, active-world PIE consistency, and per-saved-tab recovery ([ADR 0026](docs/adr/0026-stable-scene-composition-and-active-document.md))
 - [x] Editor lib/bin split + `EditorPluginGroup`; game EditorPlugin dogfood panel
 - [x] FBX/glTF model import + normalized `StaticMeshRenderer` placement; explicit scene-instance load via `bevy_ufbx` / `ModelRef`
 - [x] Asset browser model thumbnails (unified `assets/thumbnails/` pipeline; `ThumbnailState` cache; FBX via `FbxThumbnailSource`)
 - [x] Material assets (`assets/materials/*.ron`, inspector picker, drag-drop to selection)
-- [x] Prefab instance overrides v2 (transform/material/child visibility apply-revert groups)
+- [x] Prefab v2 core: shared stable nested override paths, property/component/structural scopes, recursive graph validation, linked-root variants, conflict recovery, transactional source Apply, and undoable unpack/convert ([ADR 0027](docs/adr/0027-stable-prefab-ownership-and-variants.md))
+- [x] Prefab v2 production acceptance: committed base/nested/variant fixtures pass workspace tests, recursive headless validation, packaged release startup, and live editor placement/inspection regression coverage ([Gitea #43](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/43))
+- [x] Shared project validation: editor Diagnostics and `cargo validate-levels --json` use one owner-attributed dependency/finding report across project settings, registry/import artifacts, materials, shaders, scenes, prefabs, brushes, and colliders; valid/missing/cyclic/incompatible fixtures fail on blocking content errors ([ADR 0028](docs/adr/0028-authoritative-project-content-validation.md), [Gitea #45](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/45))
+- [x] Validation-gated package foundation: versioned development/QA/release profiles, deterministic runtime exclusions, stable input snapshots, transactional staged publication, Cargo-reported artifacts, BLAKE3 metadata, authored default-scene startup, and a non-blocking editor Build panel with live logs/cancel/run/reveal ([ADR 0029](docs/adr/0029-validation-gated-build-profiles-and-packaging.md), [build guide](docs/editor/build-and-package.md), [Gitea #44](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/44))
 - [x] Advanced rendering: `GiMode`, post-process volumes, Rendering panel, requested/effective render stack, Solari integration, emissive materials, post FX assets ([ADR 0013](docs/adr/0013-rendering-tiers-and-post-process-volumes.md), [ADR 0016](docs/adr/0016-unified-rendering-contract.md), [rendering guide](docs/editor/rendering.md))
 - [x] Static mesh renderer component, generated normalized mesh artifacts, source/one-actor hierarchy placement, and inspector renderer slots ([ADR 0017](docs/adr/0017-normalized-static-mesh-assets.md))
 - [x] Componentized actor inspector, unified component cards, thumbnail static mesh slots, imported asset Browse/Locate/Clear refs with inherited source defaults, collider split, shader-aware actor material data, and texture picker/drop refs ([ADR 0018](docs/adr/0018-componentized-actor-inspector-and-materials.md))
@@ -332,9 +418,20 @@ crates/
   uses `StaticMeshRenderer` by default with imported asset refs and optional separate static mesh
   collider components. Expanded mesh subassets generate independent thumbnails and can be placed independently. Asset details can switch
   placement to **Scene Instance** for `ModelRef`/`WorldAssetRoot` playback, shared material assets can be
-  edited from the browser, and delete actions move files to `assets/.trash/`. Skeletal animation
-  playback is not supported by the static mesh path yet.
-- Prefab instances use stable asset IDs (`PrefabInstance` + registry) with serialized `PrefabOverrides` (transform, material, per-child visibility by name). Inspector **Apply/Revert** per field group; **Unpack** removes the instance link.
+  edited from the browser, and delete actions move files to `assets/.trash/`. Animation authoring
+  supports glTF/GLB rig and clip manifests, stable controller refs, clip drag assignment/placement,
+  inspector preview, PIE/runtime playback, and headless compatibility diagnostics. Animated or
+  skinned FBX remains blocked until the loader can build hierarchy, Bevy skinned meshes, and clips.
+  See the [animation authoring guide](docs/editor/animation-authoring.md).
+- Prefab instances use stable asset IDs and shared versioned override data keyed by nested
+  `PrefabActorPath` identity. Generated source members are excluded from owner save/export, while
+  property/component edits and same-layer remove/reparent operations persist as overrides. Revert
+  stays instance-local; explicit **Apply to source** validates and atomically patches the appropriate
+  source layer, with exact-file undo/redo guards against external edits. Source health exposes
+  changed, semantic-conflict, broken, and malformed states with keep/take/retry/relink recovery.
+  **Unpack Layer** preserves nested links; **Convert to Local** recursively removes them. Current
+  authoring UI coverage and production-acceptance gaps are tracked in
+  [prefab-authoring.md](docs/editor/prefab-authoring.md).
 - Material assets are RON files under `assets/materials/`; shader schemas live under `assets/shaders/`. `MaterialDesc` stores shader kind, typed parameters, texture bindings, and StandardMaterial fields. The Asset Browser material details editor can apply shader schemas, edit typed parameters/textures, and regenerate sphere thumbnails. Actor inspector material edits live on the actor `MaterialDesc`; static mesh source-material refs remain imported defaults and shared material assets are edited from the Asset Browser.
 - Per-field reflect undo for all components remains future work; typed `shared` inspectors cover the common authoring path.
 - The authoring/hydration layer is intentionally small so richer asset workflows (terrain,
diff --git a/assets/.index/registry.ron b/assets/.index/registry.ron
index f62413c..0b2bfe2 100644
--- a/assets/.index/registry.ron
+++ b/assets/.index/registry.ron
@@ -1,4 +1,36 @@
 [
+    (
+        id: ("c0a7d10e-53c1-4de0-b0dc-34a66f44ba77"),
+        path: "assets/audio/editor_audition_tone.ogg",
+        label: "editor_audition_tone",
+        kind_tag: "AudioClip",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("fe40db93-181f-4c79-86e6-26bd97464c4b"),
+        path: "assets/audio/Puzzle Lobby.mp3",
+        label: "Puzzle Lobby",
+        kind_tag: "AudioClip",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
     (
         id: ("31963299-d4c1-45dc-8f67-2f469ca1ad6d"),
         path: "assets/post_fx/chromatic_aberration.ron",
@@ -47,27 +79,6 @@
         ),
         dependencies: [],
     ),
-    (
-        id: ("71071fc3-7a7f-454d-b9ab-93ebf0feccbe"),
-        path: "assets/models/metal_stool_01_2k.gltf",
-        label: "metal_stool_01_2k",
-        kind_tag: "Model",
-        import_settings: (
-            scale: 1.0,
-            generate_collider: true,
-            lod0_only: true,
-            placement_mode: SceneInstance,
-            hierarchy_mode: SingleActor,
-            material_policy: SourceMaterials,
-            static_mesh_manifest_path: Some("assets/meshes/generated/71071fc3-7a7f-454d-b9ab-93ebf0feccbe.static_mesh.ron"),
-        ),
-        dependencies: [
-            "assets/models/metal_stool_01.bin",
-            "assets/models/textures/metal_stool_01_arm_2k.jpg",
-            "assets/models/textures/metal_stool_01_diff_2k.jpg",
-            "assets/models/textures/metal_stool_01_nor_gl_2k.jpg",
-        ],
-    ),
     (
         id: ("c4abe41c-ac88-4aec-8168-27e8a7c90583"),
         path: "assets/textures/metal_stool_01_nor_gl_2k.jpg",
@@ -120,7 +131,7 @@
         id: ("61802b85-fda9-4aff-94d9-fe5f0860c516"),
         path: "assets/levels/rendering_showcase.scn.ron",
         label: "rendering_showcase.scn",
-        kind_tag: "Prefab",
+        kind_tag: "Level",
         import_settings: (
             scale: 1.0,
             generate_collider: true,
@@ -136,7 +147,23 @@
         id: ("48bcef13-e6a6-4260-bb1b-c29787bd8c70"),
         path: "assets/levels/editor_scene 3.scn.ron",
         label: "editor_scene 3.scn",
-        kind_tag: "Prefab",
+        kind_tag: "Level",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("f3dfcd11-aa5b-4fd4-872b-06832b865c99"),
+        path: "assets/levels/audio_authoring_showcase.scn.ron",
+        label: "audio_authoring_showcase.scn",
+        kind_tag: "Level",
         import_settings: (
             scale: 1.0,
             generate_collider: true,
@@ -152,7 +179,7 @@
         id: ("5a2307d0-48e5-40d3-a5c9-527c0cfd30f4"),
         path: "assets/levels/editor_scene.scn.ron",
         label: "editor_scene.scn",
-        kind_tag: "Prefab",
+        kind_tag: "Level",
         import_settings: (
             scale: 1.0,
             generate_collider: true,
@@ -168,6 +195,54 @@
         id: ("dc13ce01-c7ce-43c5-974c-0e659ae49ab9"),
         path: "assets/levels/editor_scene 2.scn.ron",
         label: "editor_scene 2.scn",
+        kind_tag: "Level",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("c14f6240-5654-4e80-9edb-2b4c44cf8d61"),
+        path: "assets/prefabs/example_variant.scn.ron",
+        label: "example_variant.scn",
+        kind_tag: "Prefab",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("682191d6-59cd-46a1-9560-6cf7bc1583b2"),
+        path: "assets/prefabs/example_nested.scn.ron",
+        label: "example_nested.scn",
+        kind_tag: "Prefab",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("862530b2-8111-4ebb-9078-29723c002e08"),
+        path: "assets/prefabs/example_base.scn.ron",
+        label: "example_base.scn",
         kind_tag: "Prefab",
         import_settings: (
             scale: 1.0,
@@ -244,6 +319,54 @@
         ),
         dependencies: [],
     ),
+    (
+        id: ("64fea29e-c123-4987-92dc-ca25f4dc7dea"),
+        path: "assets/build_profiles/qa.ron",
+        label: "qa",
+        kind_tag: "Level",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("9213efe6-12c7-45a8-8b64-9e1699f76ba3"),
+        path: "assets/build_profiles/development.ron",
+        label: "development",
+        kind_tag: "Level",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
+    (
+        id: ("de76f1c9-f05d-48d3-bb69-6b7ce05f29d8"),
+        path: "assets/build_profiles/release.ron",
+        label: "release",
+        kind_tag: "Level",
+        import_settings: (
+            scale: 1.0,
+            generate_collider: true,
+            lod0_only: true,
+            placement_mode: StaticAsset,
+            hierarchy_mode: SingleActor,
+            material_policy: SourceMaterials,
+            static_mesh_manifest_path: None,
+        ),
+        dependencies: [],
+    ),
     (
         id: ("7b143cfb-a9e9-45d4-8f01-cfaa66fa9811"),
         path: "assets/shaders/unlit.shader.ron",
diff --git a/assets/audio/Puzzle Lobby.mp3 b/assets/audio/Puzzle Lobby.mp3
new file mode 100644
index 0000000..291d2c6
--- /dev/null
+++ b/assets/audio/Puzzle Lobby.mp3	
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6054c9d586a489deea452b966068883825d164e3ce25dafd00b8501154631c56
+size 1680820
diff --git a/assets/audio/editor_audition_tone.ogg b/assets/audio/editor_audition_tone.ogg
new file mode 100644
index 0000000..dcd71d8
--- /dev/null
+++ b/assets/audio/editor_audition_tone.ogg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc92e160ccd3d82ca86848f9db1ea3f1bd1b4f901060f3e004bc300681037390
+size 4450
diff --git a/assets/build_profiles/development.ron b/assets/build_profiles/development.ron
new file mode 100644
index 0000000..fde855f
--- /dev/null
+++ b/assets/build_profiles/development.ron
@@ -0,0 +1,10 @@
+(
+    version: 1,
+    name: "Development",
+    cargo_profile: Development,
+    target: None,
+    features: [],
+    rendering_tier: "development",
+    default_scene: Some("assets/levels/editor_scene.scn.ron"),
+    output_dir: "dist/development",
+)
diff --git a/assets/build_profiles/qa.ron b/assets/build_profiles/qa.ron
new file mode 100644
index 0000000..99ddb71
--- /dev/null
+++ b/assets/build_profiles/qa.ron
@@ -0,0 +1,10 @@
+(
+    version: 1,
+    name: "QA",
+    cargo_profile: Qa,
+    target: None,
+    features: [],
+    rendering_tier: "representative",
+    default_scene: Some("assets/levels/editor_scene.scn.ron"),
+    output_dir: "dist/qa",
+)
diff --git a/assets/build_profiles/release.ron b/assets/build_profiles/release.ron
new file mode 100644
index 0000000..0ee5edb
--- /dev/null
+++ b/assets/build_profiles/release.ron
@@ -0,0 +1,10 @@
+(
+    version: 1,
+    name: "Release",
+    cargo_profile: Release,
+    target: None,
+    features: [],
+    rendering_tier: "shipping",
+    default_scene: Some("assets/levels/editor_scene.scn.ron"),
+    output_dir: "dist/release",
+)
diff --git a/assets/levels/audio_authoring_showcase.scn.ron b/assets/levels/audio_authoring_showcase.scn.ron
new file mode 100644
index 0000000..d0d48dc
--- /dev/null
+++ b/assets/levels/audio_authoring_showcase.scn.ron
@@ -0,0 +1,56 @@
+(schema_version: 2,
+  resources: {},
+  entities: {
+    4294969001: (
+      components: {
+        "bevy_ecs::name::Name": "Audition Tone Source",
+        "bevy_transform::components::transform::Transform": (
+          translation: (0.0, 1.5, -4.0),
+          rotation: (0.0, 0.0, 0.0, 1.0),
+          scale: (1.0, 1.0, 1.0),
+        ),
+        "shared::components::LevelObject": (),
+        "shared::components::ActorId": ("audio-showcase-source"),
+        "shared::components::ActorKind": AudioSource,
+        "shared::components::AudioSourceDesc": (
+          clip: Some((
+            asset_id: "c0a7d10e-53c1-4de0-b0dc-34a66f44ba77",
+            sub_asset_id: "audio:source",
+            label: "Editor Audition Tone",
+            source_path: Some("assets/audio/editor_audition_tone.ogg"),
+          )),
+          gain_db: -6.0,
+          pitch: 1.0,
+          looping: false,
+          autoplay: true,
+          spatial_blend: 1.0,
+          attenuation: (
+            min_distance: 1.0,
+            max_distance: 18.0,
+            rolloff: Inverse,
+            rolloff_factor: 1.0,
+          ),
+          bus: "sfx",
+        ),
+      },
+    ),
+    4294969002: (
+      components: {
+        "bevy_ecs::name::Name": "Showcase Listener",
+        "bevy_transform::components::transform::Transform": (
+          translation: (0.0, 1.7, 0.0),
+          rotation: (0.0, 0.0, 0.0, 1.0),
+          scale: (1.0, 1.0, 1.0),
+        ),
+        "shared::components::LevelObject": (),
+        "shared::components::ActorId": ("audio-showcase-listener"),
+        "shared::components::ActorKind": AudioListener,
+        "shared::components::AudioListenerDesc": (
+          enabled: true,
+          priority: 100,
+          ear_gap: 0.2,
+        ),
+      },
+    ),
+  },
+)
diff --git a/assets/meshes/generated/71071fc3-7a7f-454d-b9ab-93ebf0feccbe.static_mesh.ron b/assets/meshes/generated/71071fc3-7a7f-454d-b9ab-93ebf0feccbe.static_mesh.ron
deleted file mode 100644
index 33bee9d..0000000
--- a/assets/meshes/generated/71071fc3-7a7f-454d-b9ab-93ebf0feccbe.static_mesh.ron
+++ /dev/null
@@ -1,55 +0,0 @@
-(
-    schema_version: 1,
-    asset_id: "71071fc3-7a7f-454d-b9ab-93ebf0feccbe",
-    label: "metal_stool_01_2k",
-    source: (
-        path: "assets/models/metal_stool_01_2k.gltf",
-        format: "gltf",
-        fingerprint: (
-            byte_len: 2790,
-            modified_unix_secs: 1780734867,
-        ),
-        dependencies: [
-            "assets/models/metal_stool_01.bin",
-            "assets/models/textures/metal_stool_01_arm_2k.jpg",
-            "assets/models/textures/metal_stool_01_diff_2k.jpg",
-            "assets/models/textures/metal_stool_01_nor_gl_2k.jpg",
-        ],
-    ),
-    import: (
-        scale: 1.0,
-        generate_collider: true,
-        lod0_only: true,
-        placement_mode: SceneInstance,
-        hierarchy_mode: SingleActor,
-        material_policy: SourceMaterials,
-    ),
-    metadata: (
-        mesh_count: 1,
-        material_count: 1,
-        node_count: 1,
-        animation_count: 0,
-        skin_count: 0,
-        light_count: 0,
-        camera_count: 0,
-    ),
-    parts: [
-        (
-            id: "mesh:mesh0_primitive0",
-            name: "metal_stool_01 / Primitive 0",
-            mesh_label: "Mesh0/Primitive0",
-            material_id: Some("material:material0"),
-            material_slot_name: "metal_stool_01",
-            material_label: Some("Material0"),
-            local_transform: (
-                translation: (0.0, 0.0, 0.0),
-                rotation: (0.0, 0.0, 0.0, 1.0),
-                scale: (1.0, 1.0, 1.0),
-            ),
-            source_node: Some("Node0"),
-            source_mesh: Some("Mesh0"),
-            source_material: Some("metal_stool_01"),
-        ),
-    ],
-    warnings: [],
-)
\ No newline at end of file
diff --git a/assets/models/metal_stool_01_2k.gltf b/assets/models/metal_stool_01_2k.gltf
deleted file mode 100644
index 88d9e41..0000000
--- a/assets/models/metal_stool_01_2k.gltf
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c5886418d98b7ec4e932f54a2ba44896dd9e61276bf62d21697b9136f2b0803e
-size 2790
diff --git a/assets/models/robot_expressive.LICENSE.md b/assets/models/robot_expressive.LICENSE.md
new file mode 100644
index 0000000..eb1d131
--- /dev/null
+++ b/assets/models/robot_expressive.LICENSE.md
@@ -0,0 +1,12 @@
+# RobotExpressive License And Attribution
+
+`robot_expressive.glb` is the RobotExpressive model from the Three.js example assets.
+
+- Model: Tomas Laulhe (Quaternius)
+- Modifications and glTF conversion: Don McCurdy
+- License: CC0 1.0 Universal
+- Source: https://github.com/mrdoob/three.js/tree/dev/examples/models/gltf/RobotExpressive
+- Imported source SHA-256: `047f5e5fb3bb6d378bd1df16ca6137f2a596c99b3a1b5690b4020c05aaf6f319`
+
+The upstream modifications add facial-expression morph targets, convert the source with FBX2GLTF,
+remove duplicate materials, and reduce material metalness.
diff --git a/assets/models/robot_expressive.glb b/assets/models/robot_expressive.glb
new file mode 100644
index 0000000..7cb7550
--- /dev/null
+++ b/assets/models/robot_expressive.glb
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:047f5e5fb3bb6d378bd1df16ca6137f2a596c99b3a1b5690b4020c05aaf6f319
+size 463988
diff --git a/assets/prefabs/README.md b/assets/prefabs/README.md
new file mode 100644
index 0000000..dbd6a11
--- /dev/null
+++ b/assets/prefabs/README.md
@@ -0,0 +1,10 @@
+# Prefab fixtures
+
+The `example_base` -> `example_nested` -> `example_variant` chain is the production-format
+fixture for linked prefab ownership, nested stable actor paths, and variant override layering.
+The variant hides `base-mesh` through an `EditorVisibility` component override targeted as
+`nested-link / base-link / base-mesh` when the variant is placed in a scene.
+
+Keep these files loadable by the editor and valid under `cargo validate-levels`. Broken-source,
+cycle, and conflict fixtures belong in temporary test projects so the shipped asset tree remains
+healthy.
diff --git a/assets/prefabs/example_base.scn.ron b/assets/prefabs/example_base.scn.ron
new file mode 100644
index 0000000..23ca1dc
--- /dev/null
+++ b/assets/prefabs/example_base.scn.ron
@@ -0,0 +1,19 @@
+(schema_version: 2,
+  resources: {},
+  entities: {
+    1: (
+      components: {
+        "bevy_ecs::name::Name": "Example Base Mesh",
+        "bevy_transform::components::transform::Transform": (
+          translation: (0.0, 0.0, 0.0),
+          rotation: (0.0, 0.0, 0.0, 1.0),
+          scale: (1.0, 1.0, 1.0),
+        ),
+        "shared::components::ActorId": ("base-mesh"),
+        "shared::components::ActorKind": Empty,
+        "shared::components::EditorVisibility": (visible: true),
+        "shared::components::LevelObject": (),
+      },
+    ),
+  },
+)
diff --git a/assets/prefabs/example_nested.scn.ron b/assets/prefabs/example_nested.scn.ron
new file mode 100644
index 0000000..8039fbd
--- /dev/null
+++ b/assets/prefabs/example_nested.scn.ron
@@ -0,0 +1,23 @@
+(schema_version: 2,
+  resources: {},
+  entities: {
+    1: (
+      components: {
+        "bevy_ecs::name::Name": "Example Base Link",
+        "bevy_transform::components::transform::Transform": (
+          translation: (0.0, 0.0, 0.0),
+          rotation: (0.0, 0.0, 0.0, 1.0),
+          scale: (1.0, 1.0, 1.0),
+        ),
+        "shared::components::ActorId": ("base-link"),
+        "shared::components::ActorKind": PrefabAnchor,
+        "shared::components::LevelObject": (),
+        "shared::components::PrefabInstance": (
+          asset_id: "11111111-1111-4111-8111-111111111111",
+          source_path: "assets/prefabs/example_base.scn.ron",
+          overrides_ron: None,
+        ),
+      },
+    ),
+  },
+)
diff --git a/assets/prefabs/example_variant.scn.ron b/assets/prefabs/example_variant.scn.ron
new file mode 100644
index 0000000..852daf7
--- /dev/null
+++ b/assets/prefabs/example_variant.scn.ron
@@ -0,0 +1,23 @@
+(schema_version: 2,
+  resources: {},
+  entities: {
+    1: (
+      components: {
+        "bevy_ecs::name::Name": "Example Nested Variant Link",
+        "bevy_transform::components::transform::Transform": (
+          translation: (0.0, 0.0, 0.0),
+          rotation: (0.0, 0.0, 0.0, 1.0),
+          scale: (1.0, 1.0, 1.0),
+        ),
+        "shared::components::ActorId": ("nested-link"),
+        "shared::components::ActorKind": PrefabAnchor,
+        "shared::components::LevelObject": (),
+        "shared::components::PrefabInstance": (
+          asset_id: "22222222-2222-4222-8222-222222222222",
+          source_path: "assets/prefabs/example_nested.scn.ron",
+          overrides_ron: Some("(format_version:2,source_revision:None,transform:None,material:None,child_visibility:{},properties:[],components:[(target:(instance_chain:[\"base-link\"],actor_id:\"base-mesh\"),component_type:\"shared::components::EditorVisibility\",base_component_ron:Some(\"(visible:true)\"),value_component_ron:Some(\"(visible:false)\"))],structural:[])"),
+        ),
+      },
+    ),
+  },
+)
diff --git a/assets/project.ron b/assets/project.ron
index d2ba3c8..ca7e10d 100644
--- a/assets/project.ron
+++ b/assets/project.ron
@@ -1,8 +1,13 @@
 (
     version: 1,
+    project_id: "blacksite-foundation",
     name: "Bevy FPS Foundation",
+    project_kind: Game,
+    template_version: 1,
+    capabilities: ["editor", "gameplay", "rendering", "audio", "solari"],
     default_level: "assets/levels/editor_scene.scn.ron",
     asset_roots: [
+        "assets/audio",
         "assets/models",
         "assets/textures",
         "assets/materials",
@@ -29,6 +34,31 @@
         shadow_first_cascade: 6.0,
         shadow_max_distance: 220.0,
     ),
+    audio: (
+        buses: [
+            (
+                id: "master",
+                label: "Master",
+                parent: None,
+                gain_db: 0.0,
+                muted: false,
+            ),
+            (
+                id: "music",
+                label: "Music",
+                parent: Some("master"),
+                gain_db: 0.0,
+                muted: false,
+            ),
+            (
+                id: "sfx",
+                label: "SFX",
+                parent: Some("master"),
+                gain_db: 0.0,
+                muted: false,
+            ),
+        ],
+    ),
     physics: (
         player_radius: 0.4,
         player_length: 1.0,
diff --git a/crates/editor/Cargo.toml b/crates/editor/Cargo.toml
index 6c8935a..f5a06b9 100644
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -4,6 +4,7 @@ version.workspace = true
 edition.workspace = true
 license.workspace = true
 description = "In-process level editor for the Bevy FPS foundation"
+default-run = "editor"
 
 [lib]
 name = "editor"
@@ -13,6 +14,10 @@ path = "src/lib.rs"
 name = "editor"
 path = "src/bin/main.rs"
 
+[[bin]]
+name = "project_launcher"
+path = "src/bin/project_launcher.rs"
+
 [features]
 dev = ["bevy/dynamic_linking", "game/dev"]
 hot-reload = ["game/hot-reload", "dep:hot-lib-reloader", "dep:notify"]
@@ -37,9 +42,11 @@ sim.workspace = true
 settings.workspace = true
 scene.workspace = true
 serde.workspace = true
+serde_json = "1"
 transform-gizmo-bevy.workspace = true
 rfd = "0.17.2"
 ron = "0.8"
 uuid = { version = "1", features = ["v4", "serde"] }
 walkdir = "2.5"
-gltf = "1.4"
+gltf = { version = "1.4", features = ["extras"] }
+blake3 = "1"
diff --git a/crates/editor/src/assets/animation.rs b/crates/editor/src/assets/animation.rs
new file mode 100644
index 0000000..7e5d38d
--- /dev/null
+++ b/crates/editor/src/assets/animation.rs
@@ -0,0 +1,833 @@
+//! Generated animation artifacts for imported model sources.
+
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+use std::time::UNIX_EPOCH;
+
+use serde::Deserialize;
+use shared::{
+    animation_clip_sub_asset_id, animation_skeleton_sub_asset_id, AnimationClipRecord,
+    AnimationDiagnosticSeverity, AnimationEventDesc, AnimationImportDiagnostic, AnimationManifest,
+    AnimationManifestSource, AnimationSkeletonRecord, AnimationSkeletonSignature,
+    AnimationSourceFingerprint, ANIMATION_ARTIFACT_DIR, ANIMATION_MANIFEST_SCHEMA_VERSION,
+};
+
+use crate::asset_db::AssetRecord;
+
+pub fn animation_manifest_path(asset_id: &str) -> String {
+    format!("{ANIMATION_ARTIFACT_DIR}/{asset_id}.animation.ron")
+}
+
+pub fn refresh_animation_artifact(record: &mut AssetRecord) -> Result<AnimationManifest, String> {
+    let mut manifest = build_animation_manifest(record)?;
+    manifest.source.dependencies.sort();
+    manifest.source.dependencies.dedup();
+
+    let path = animation_manifest_path(&record.id.as_string());
+    record.import_settings.animation_manifest_path = Some(path.clone());
+    record
+        .dependencies
+        .extend(manifest.source.dependencies.iter().cloned());
+    record.dependencies.sort();
+    record.dependencies.dedup();
+
+    let text = ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default())
+        .map_err(|error| format!("could not serialize animation manifest: {error}"))?;
+    if let Some(parent) = Path::new(&path).parent() {
+        fs::create_dir_all(parent)
+            .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+    }
+    if fs::read_to_string(&path).ok().as_deref() != Some(text.as_str()) {
+        fs::write(&path, text)
+            .map_err(|error| format!("could not write animation manifest {path}: {error}"))?;
+        bevy::log::info!(
+            "Animation manifest refreshed: source={} artifact={} skeletons={} clips={} runtime_supported={}",
+            record.path,
+            path,
+            manifest.skeletons.len(),
+            manifest.clips.len(),
+            manifest.runtime_supported
+        );
+    }
+
+    Ok(manifest)
+}
+
+pub fn load_animation_manifest(path: &str) -> Result<AnimationManifest, String> {
+    let text =
+        fs::read_to_string(path).map_err(|error| format!("could not read {path}: {error}"))?;
+    ron::from_str(&text).map_err(|error| format!("could not parse {path}: {error}"))
+}
+
+pub fn build_animation_manifest(record: &AssetRecord) -> Result<AnimationManifest, String> {
+    let bytes = fs::read(&record.path)
+        .map_err(|error| format!("could not read {}: {error}", record.path))?;
+    let fingerprint = source_fingerprint(&record.path, &bytes)?;
+    let format = source_format(&record.path)?;
+    match format.as_str() {
+        "gltf" | "glb" => build_gltf_manifest(record, format, fingerprint, &bytes),
+        "fbx" => build_fbx_manifest(record, format, fingerprint, &bytes),
+        _ => Err(format!("unsupported animation source format `{format}`")),
+    }
+}
+
+#[derive(Debug, Clone)]
+struct SkeletonCandidate {
+    compatible_nodes: BTreeSet<usize>,
+    signature: AnimationSkeletonSignature,
+}
+
+fn build_gltf_manifest(
+    record: &AssetRecord,
+    format: String,
+    fingerprint: AnimationSourceFingerprint,
+    bytes: &[u8],
+) -> Result<AnimationManifest, String> {
+    let gltf = gltf::Gltf::from_slice(bytes)
+        .map_err(|error| format!("could not parse glTF {}: {error}", record.path))?;
+    let base = Path::new(&record.path).parent();
+    let buffers = gltf::import_buffers(&gltf.document, base, gltf.blob.clone())
+        .map_err(|error| format!("could not load glTF buffers for {}: {error}", record.path))?;
+
+    let mut dependencies = gltf
+        .document
+        .buffers()
+        .filter_map(|buffer| match buffer.source() {
+            gltf::buffer::Source::Uri(uri) if !uri.starts_with("data:") => {
+                Some(resolve_dependency(&record.path, uri))
+            }
+            _ => None,
+        })
+        .collect::<Vec<_>>();
+    dependencies.sort();
+    dependencies.dedup();
+
+    let node_identity_names = gltf
+        .document
+        .nodes()
+        .map(|node| bevy_node_segment(node.name(), node.index()))
+        .collect::<Vec<_>>();
+    let readable_node_names = gltf
+        .document
+        .nodes()
+        .map(|node| normalized_node_segment(node.name(), node.index()))
+        .collect::<Vec<_>>();
+    let mut parents = vec![None; node_identity_names.len()];
+    for node in gltf.document.nodes() {
+        for child in node.children() {
+            parents[child.index()] = Some(node.index());
+        }
+    }
+
+    let mut skeletons = Vec::new();
+    let mut candidates = Vec::new();
+    for skin in gltf.document.skins() {
+        let source_index = skin.index();
+        let label = skin
+            .name()
+            .filter(|name| !name.trim().is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| format!("Skeleton {source_index}"));
+        let joint_indices = skin.joints().map(|joint| joint.index()).collect::<Vec<_>>();
+        let joint_identity_paths = joint_indices
+            .iter()
+            .map(|index| node_path_segments(*index, &node_identity_names, &parents))
+            .collect::<Vec<_>>();
+        let joint_paths = joint_indices
+            .iter()
+            .map(|index| node_path(*index, &readable_node_names, &parents))
+            .collect::<Vec<_>>();
+        let bind_poses = skin
+            .reader(|buffer| Some(buffers[buffer.index()].0.as_slice()))
+            .read_inverse_bind_matrices()
+            .map(|matrices| matrices.map(gltf_matrix_bytes).collect::<Vec<_>>())
+            .unwrap_or_else(|| vec![identity_matrix_bytes(); joint_paths.len()]);
+        let signature = skeleton_signature(&joint_identity_paths, &bind_poses);
+        let mut compatible_nodes = joint_indices.into_iter().collect::<BTreeSet<_>>();
+        if let Some(root) = skin.skeleton() {
+            compatible_nodes.insert(root.index());
+        }
+        candidates.push(SkeletonCandidate {
+            compatible_nodes,
+            signature: signature.clone(),
+        });
+        skeletons.push(AnimationSkeletonRecord {
+            id: animation_skeleton_sub_asset_id(source_index, &label),
+            label,
+            source_index,
+            signature,
+            joint_paths,
+        });
+    }
+
+    let mut diagnostics = Vec::new();
+    let mut clips = Vec::new();
+    let mut animation_roots = BTreeSet::new();
+    for animation in gltf.document.animations() {
+        let source_index = animation.index();
+        let label = animation
+            .name()
+            .filter(|name| !name.trim().is_empty())
+            .map(str::to_string)
+            .unwrap_or_else(|| format!("Animation {source_index}"));
+        let mut duration_seconds = 0.0_f32;
+        let mut target_nodes = BTreeSet::new();
+        for channel in animation.channels() {
+            let target_index = channel.target().node().index();
+            target_nodes.insert(target_index);
+            animation_roots.insert(top_level_node(target_index, &parents));
+            if let Some(inputs) = channel
+                .reader(|buffer| Some(buffers[buffer.index()].0.as_slice()))
+                .read_inputs()
+            {
+                for input in inputs {
+                    if input.is_finite() {
+                        duration_seconds = duration_seconds.max(input);
+                    }
+                }
+            }
+        }
+        let target_skeleton_signature = matching_skeleton_signature(&target_nodes, &candidates);
+        if !candidates.is_empty() && target_skeleton_signature.is_none() {
+            diagnostics.push(AnimationImportDiagnostic {
+                severity: AnimationDiagnosticSeverity::Warning,
+                code: "animation.clip_skeleton_unresolved".into(),
+                message: format!(
+                    "clip `{label}` does not target a uniquely identifiable imported skeleton"
+                ),
+                repair: "Export the clip with channels targeting one skeleton, or split unrelated rigs into separate glTF assets.".into(),
+            });
+        }
+        let events = gltf_animation_events(&animation, duration_seconds, &label, &mut diagnostics);
+        clips.push(AnimationClipRecord {
+            id: animation_clip_sub_asset_id(source_index, &label),
+            label,
+            source_index,
+            duration_seconds,
+            target_skeleton_signature,
+            events,
+        });
+    }
+
+    let runtime_supported = animation_roots.len() <= 1;
+    if !runtime_supported {
+        let roots = animation_roots
+            .iter()
+            .map(|index| format!("`{}` (node {index})", node_identity_names[*index]))
+            .collect::<Vec<_>>()
+            .join(", ");
+        diagnostics.push(AnimationImportDiagnostic {
+            severity: AnimationDiagnosticSeverity::Error,
+            code: "animation.multiple_roots_unsupported".into(),
+            message: format!(
+                "animation channels target {} distinct top-level roots ({roots}); Bevy requires a separate AnimationPlayer for each root",
+                animation_roots.len()
+            ),
+            repair: "Split the source into one animated rig per glTF asset, or export every clip under one common top-level root, then reimport.".into(),
+        });
+    }
+
+    Ok(AnimationManifest {
+        schema_version: ANIMATION_MANIFEST_SCHEMA_VERSION,
+        asset_id: record.id.as_string(),
+        label: record.label.clone(),
+        source: AnimationManifestSource {
+            path: record.path.clone(),
+            format,
+            fingerprint,
+            dependencies,
+        },
+        runtime_supported,
+        skeletons,
+        clips,
+        diagnostics,
+    })
+}
+
+fn build_fbx_manifest(
+    record: &AssetRecord,
+    format: String,
+    fingerprint: AnimationSourceFingerprint,
+    bytes: &[u8],
+) -> Result<AnimationManifest, String> {
+    let scene = ufbx::load_memory(
+        bytes,
+        ufbx::LoadOpts {
+            target_unit_meters: 1.0,
+            target_axes: ufbx::CoordinateAxes::right_handed_y_up(),
+            ..Default::default()
+        },
+    )
+    .map_err(|error| format!("could not parse FBX {}: {error:?}", record.path))?;
+
+    let mut skeletons = Vec::new();
+    for (source_index, skin) in scene.skin_deformers.as_ref().iter().enumerate() {
+        let label = if skin.element.name.is_empty() {
+            format!("Skeleton {source_index}")
+        } else {
+            skin.element.name.to_string()
+        };
+        let mut joint_identity_paths = Vec::new();
+        let mut joint_paths = Vec::new();
+        let mut bind_poses = Vec::new();
+        for cluster in skin.clusters.as_ref() {
+            let Some(bone) = cluster.bone_node.as_ref() else {
+                continue;
+            };
+            let segments = fbx_node_path_segments(bone.as_ref());
+            joint_paths.push(segments.join("/"));
+            joint_identity_paths.push(segments);
+            bind_poses.push(fbx_matrix_bytes(&cluster.bind_to_world));
+        }
+        let signature = skeleton_signature(&joint_identity_paths, &bind_poses);
+        skeletons.push(AnimationSkeletonRecord {
+            id: animation_skeleton_sub_asset_id(source_index, &label),
+            label,
+            source_index,
+            signature,
+            joint_paths,
+        });
+    }
+
+    let fallback_signature = (skeletons.len() == 1).then(|| skeletons[0].signature.clone());
+    let clips = scene
+        .anim_stacks
+        .as_ref()
+        .iter()
+        .enumerate()
+        .map(|(source_index, stack)| {
+            let label = if stack.element.name.is_empty() {
+                format!("Animation {source_index}")
+            } else {
+                stack.element.name.to_string()
+            };
+            AnimationClipRecord {
+                id: animation_clip_sub_asset_id(source_index, &label),
+                label,
+                source_index,
+                duration_seconds: (stack.time_end - stack.time_begin).max(0.0) as f32,
+                target_skeleton_signature: fallback_signature.clone(),
+                events: Vec::new(),
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let (runtime_supported, diagnostics) = fbx_runtime_support(
+        scene.anim_stacks.as_ref().len(),
+        scene.skin_deformers.as_ref().len(),
+    );
+
+    Ok(AnimationManifest {
+        schema_version: ANIMATION_MANIFEST_SCHEMA_VERSION,
+        asset_id: record.id.as_string(),
+        label: record.label.clone(),
+        source: AnimationManifestSource {
+            path: record.path.clone(),
+            format,
+            fingerprint,
+            dependencies: Vec::new(),
+        },
+        runtime_supported,
+        skeletons,
+        clips,
+        diagnostics,
+    })
+}
+
+fn fbx_runtime_support(
+    animation_count: usize,
+    skin_count: usize,
+) -> (bool, Vec<AnimationImportDiagnostic>) {
+    let mut diagnostics = Vec::new();
+    if animation_count > 0 || skin_count > 0 {
+        diagnostics.push(AnimationImportDiagnostic {
+            severity: AnimationDiagnosticSeverity::Error,
+            code: "animation.fbx_runtime_unsupported".into(),
+            message: format!(
+                "FBX contains {animation_count} animation stack(s) and {skin_count} skin deformer(s), but Blacksite's current FBX loader cannot build a runtime skeleton or clips"
+            ),
+            repair: "Export the animated source as glTF 2.0 (.glb or .gltf). Keep FBX only for static mesh import until hierarchy, SkinnedMesh, and AnimationClip conversion are implemented.".into(),
+        });
+    }
+    (false, diagnostics)
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct GltfAnimationExtras {
+    #[serde(default)]
+    blacksite_events: Vec<GltfAnimationEvent>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GltfAnimationEvent {
+    id: String,
+    time_seconds: f32,
+    #[serde(default)]
+    payload: Option<String>,
+}
+
+fn gltf_animation_events(
+    animation: &gltf::Animation<'_>,
+    duration_seconds: f32,
+    clip_label: &str,
+    diagnostics: &mut Vec<AnimationImportDiagnostic>,
+) -> Vec<AnimationEventDesc> {
+    let Some(raw) = animation.extras().as_ref() else {
+        return Vec::new();
+    };
+    let extras = match serde_json::from_str::<GltfAnimationExtras>(raw.get()) {
+        Ok(extras) => extras,
+        Err(error) => {
+            diagnostics.push(AnimationImportDiagnostic {
+                severity: AnimationDiagnosticSeverity::Warning,
+                code: "animation.events_invalid".into(),
+                message: format!("clip `{clip_label}` has invalid animation event metadata: {error}"),
+                repair: "Use an animation extras object with `blacksite_events` entries containing `id`, `time_seconds`, and optional string `payload`.".into(),
+            });
+            return Vec::new();
+        }
+    };
+
+    let mut events = Vec::new();
+    for event in extras.blacksite_events {
+        let valid_time = event.time_seconds.is_finite()
+            && event.time_seconds >= 0.0
+            && event.time_seconds <= duration_seconds;
+        if event.id.trim().is_empty() || !valid_time {
+            diagnostics.push(AnimationImportDiagnostic {
+                severity: AnimationDiagnosticSeverity::Warning,
+                code: "animation.event_out_of_range".into(),
+                message: format!(
+                    "clip `{clip_label}` contains an event with an empty ID or time outside 0..={duration_seconds:.3}s"
+                ),
+                repair: "Give every event a stable non-empty ID and place it within the imported clip duration.".into(),
+            });
+            continue;
+        }
+        events.push(AnimationEventDesc {
+            id: event.id,
+            time_seconds: event.time_seconds,
+            payload: event.payload,
+        });
+    }
+    events.sort_by(|left, right| {
+        left.time_seconds
+            .total_cmp(&right.time_seconds)
+            .then(left.id.cmp(&right.id))
+            .then(left.payload.cmp(&right.payload))
+    });
+    events
+}
+
+fn matching_skeleton_signature(
+    target_nodes: &BTreeSet<usize>,
+    candidates: &[SkeletonCandidate],
+) -> Option<AnimationSkeletonSignature> {
+    let scored = candidates
+        .iter()
+        .map(|candidate| {
+            (
+                candidate
+                    .compatible_nodes
+                    .intersection(target_nodes)
+                    .count(),
+                candidate,
+            )
+        })
+        .filter(|(score, _)| *score > 0)
+        .collect::<Vec<_>>();
+    let best_score = scored.iter().map(|(score, _)| *score).max()?;
+    let mut best = scored
+        .into_iter()
+        .filter(|(score, _)| *score == best_score)
+        .map(|(_, candidate)| candidate);
+    let candidate = best.next()?;
+    best.all(|other| other.signature == candidate.signature)
+        .then(|| candidate.signature.clone())
+}
+
+fn node_path(index: usize, names: &[String], parents: &[Option<usize>]) -> String {
+    node_path_segments(index, names, parents).join("/")
+}
+
+fn node_path_segments(index: usize, names: &[String], parents: &[Option<usize>]) -> Vec<String> {
+    let mut segments = Vec::new();
+    let mut current = Some(index);
+    while let Some(node_index) = current {
+        segments.push(names[node_index].clone());
+        current = parents[node_index];
+    }
+    segments.reverse();
+    segments
+}
+
+fn top_level_node(index: usize, parents: &[Option<usize>]) -> usize {
+    let mut current = index;
+    while let Some(parent) = parents[current] {
+        current = parent;
+    }
+    current
+}
+
+fn bevy_node_segment(name: Option<&str>, index: usize) -> String {
+    name.map(str::to_string)
+        .unwrap_or_else(|| format!("GltfNode{index}"))
+}
+
+fn normalized_node_segment(name: Option<&str>, index: usize) -> String {
+    name.map(str::trim)
+        .filter(|name| !name.is_empty())
+        .map(|name| name.replace(['/', '\\'], "_"))
+        .unwrap_or_else(|| format!("Node{index}"))
+}
+
+fn fbx_node_path_segments(node: &ufbx::Node) -> Vec<String> {
+    let mut segments = Vec::new();
+    let mut current = Some(node);
+    while let Some(node) = current {
+        segments.push(normalized_node_segment(
+            (!node.element.name.is_empty()).then(|| node.element.name.as_ref()),
+            node.element.element_id as usize,
+        ));
+        current = node.parent.as_ref().map(|parent| parent.as_ref());
+    }
+    segments.reverse();
+    segments
+}
+
+fn skeleton_signature(
+    joint_path_segments: &[Vec<String>],
+    bind_pose_bytes: &[Vec<u8>],
+) -> AnimationSkeletonSignature {
+    let mut hasher = blake3::Hasher::new();
+    hasher.update(b"blacksite-animation-skeleton-v2\0");
+    hasher.update(&(joint_path_segments.len() as u64).to_le_bytes());
+    for path in joint_path_segments {
+        hasher.update(&(path.len() as u64).to_le_bytes());
+        for segment in path {
+            let bytes = segment.as_bytes();
+            hasher.update(&(bytes.len() as u64).to_le_bytes());
+            hasher.update(bytes);
+        }
+    }
+    hasher.update(&(bind_pose_bytes.len() as u64).to_le_bytes());
+    for bytes in bind_pose_bytes {
+        hasher.update(&(bytes.len() as u64).to_le_bytes());
+        hasher.update(bytes);
+    }
+    AnimationSkeletonSignature::new(hasher.finalize().to_hex().to_string())
+}
+
+fn gltf_matrix_bytes(matrix: [[f32; 4]; 4]) -> Vec<u8> {
+    matrix
+        .into_iter()
+        .flatten()
+        .flat_map(f32::to_le_bytes)
+        .collect()
+}
+
+fn identity_matrix_bytes() -> Vec<u8> {
+    gltf_matrix_bytes([
+        [1.0, 0.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0, 0.0],
+        [0.0, 0.0, 1.0, 0.0],
+        [0.0, 0.0, 0.0, 1.0],
+    ])
+}
+
+fn fbx_matrix_bytes(matrix: &ufbx::Matrix) -> Vec<u8> {
+    [
+        matrix.m00, matrix.m10, matrix.m20, matrix.m01, matrix.m11, matrix.m21, matrix.m02,
+        matrix.m12, matrix.m22, matrix.m03, matrix.m13, matrix.m23,
+    ]
+    .into_iter()
+    .flat_map(f64::to_le_bytes)
+    .collect()
+}
+
+fn source_fingerprint(path: &str, bytes: &[u8]) -> Result<AnimationSourceFingerprint, String> {
+    let metadata = fs::metadata(path).map_err(|error| format!("could not stat {path}: {error}"))?;
+    let modified_unix_secs = metadata
+        .modified()
+        .ok()
+        .and_then(|time| time.duration_since(UNIX_EPOCH).ok())
+        .map(|duration| duration.as_secs())
+        .unwrap_or_default();
+    Ok(AnimationSourceFingerprint {
+        byte_len: metadata.len(),
+        modified_unix_secs,
+        content_hash: blake3::hash(bytes).to_hex().to_string(),
+    })
+}
+
+fn source_format(path: &str) -> Result<String, String> {
+    Path::new(path)
+        .extension()
+        .and_then(|extension| extension.to_str())
+        .map(|extension| extension.to_ascii_lowercase())
+        .ok_or_else(|| format!("asset path `{path}` has no extension"))
+}
+
+fn resolve_dependency(source_path: &str, uri: &str) -> String {
+    Path::new(source_path)
+        .parent()
+        .unwrap_or_else(|| Path::new(""))
+        .join(uri)
+        .to_string_lossy()
+        .replace('\\', "/")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::asset_db::{AssetId, ImportSettings};
+    use uuid::Uuid;
+
+    fn fixture_record(path: &Path) -> AssetRecord {
+        AssetRecord {
+            id: AssetId(Uuid::nil()),
+            path: path.to_string_lossy().replace('\\', "/"),
+            label: "Animated Hero".into(),
+            kind_tag: "Model".into(),
+            import_settings: ImportSettings::default(),
+            dependencies: Vec::new(),
+        }
+    }
+
+    fn write_animated_gltf(root: &Path) -> std::path::PathBuf {
+        fs::create_dir_all(root).unwrap();
+        let mut buffer = Vec::new();
+        for value in [0.0_f32, 1.25] {
+            buffer.extend_from_slice(&value.to_le_bytes());
+        }
+        for value in [0.0_f32, 0.0, 0.0, 1.0, 0.0, 0.38268343, 0.0, 0.9238795] {
+            buffer.extend_from_slice(&value.to_le_bytes());
+        }
+        fs::write(root.join("animated.bin"), buffer).unwrap();
+        let gltf = r#"{
+          "asset":{"version":"2.0"},
+          "scene":0,
+          "scenes":[{"nodes":[0]}],
+          "nodes":[{"name":"Armature","children":[1]},{"name":"Hip"}],
+          "skins":[{"name":"Hero Rig","skeleton":0,"joints":[1]}],
+          "buffers":[{"uri":"animated.bin","byteLength":40}],
+          "bufferViews":[
+            {"buffer":0,"byteOffset":0,"byteLength":8},
+            {"buffer":0,"byteOffset":8,"byteLength":32}
+          ],
+          "accessors":[
+            {"bufferView":0,"componentType":5126,"count":2,"type":"SCALAR","min":[0.0],"max":[1.25]},
+            {"bufferView":1,"componentType":5126,"count":2,"type":"VEC4"}
+          ],
+          "animations":[{
+            "name":"Idle Loop",
+            "samplers":[{"input":0,"output":1,"interpolation":"LINEAR"}],
+            "channels":[{"sampler":0,"target":{"node":1,"path":"rotation"}}],
+            "extras":{"blacksite_events":[{"id":"footstep.left","time_seconds":0.5,"payload":"stone"}]}
+          }]
+        }"#;
+        let path = root.join("animated.gltf");
+        fs::write(&path, gltf).unwrap();
+        path
+    }
+
+    fn write_multi_root_animated_gltf(root: &Path) -> std::path::PathBuf {
+        fs::create_dir_all(root).unwrap();
+        let mut buffer = Vec::new();
+        for value in [0.0_f32, 1.0] {
+            buffer.extend_from_slice(&value.to_le_bytes());
+        }
+        for value in [0.0_f32, 0.0, 0.0, 1.0, 0.0, 0.38268343, 0.0, 0.9238795] {
+            buffer.extend_from_slice(&value.to_le_bytes());
+        }
+        fs::write(root.join("multi-root.bin"), buffer).unwrap();
+        let gltf = r#"{
+          "asset":{"version":"2.0"},
+          "scene":0,
+          "scenes":[{"nodes":[0,2]}],
+          "nodes":[
+            {"name":"Character A","children":[1]},
+            {"name":"Joint A"},
+            {"name":"Character B","children":[3]},
+            {"name":"Joint B"}
+          ],
+          "buffers":[{"uri":"multi-root.bin","byteLength":40}],
+          "bufferViews":[
+            {"buffer":0,"byteOffset":0,"byteLength":8},
+            {"buffer":0,"byteOffset":8,"byteLength":32}
+          ],
+          "accessors":[
+            {"bufferView":0,"componentType":5126,"count":2,"type":"SCALAR","min":[0.0],"max":[1.0]},
+            {"bufferView":1,"componentType":5126,"count":2,"type":"VEC4"}
+          ],
+          "animations":[{
+            "name":"Two Players Required",
+            "samplers":[
+              {"input":0,"output":1,"interpolation":"LINEAR"},
+              {"input":0,"output":1,"interpolation":"LINEAR"}
+            ],
+            "channels":[
+              {"sampler":0,"target":{"node":1,"path":"rotation"}},
+              {"sampler":1,"target":{"node":3,"path":"rotation"}}
+            ]
+          }]
+        }"#;
+        let path = root.join("multi-root.gltf");
+        fs::write(&path, gltf).unwrap();
+        path
+    }
+
+    #[test]
+    fn animation_manifest_path_uses_registry_uuid() {
+        assert_eq!(
+            animation_manifest_path("abc"),
+            "assets/animations/generated/abc.animation.ron"
+        );
+    }
+
+    #[test]
+    fn gltf_extraction_is_deterministic_and_preserves_duration_events_and_signature() {
+        let root = std::env::temp_dir().join(format!("blacksite-animation-{}", Uuid::new_v4()));
+        let path = write_animated_gltf(&root);
+        let record = fixture_record(&path);
+
+        let first = build_animation_manifest(&record).unwrap();
+        let second = build_animation_manifest(&record).unwrap();
+
+        assert_eq!(first, second);
+        assert_eq!(first.schema_version, 2);
+        assert!(first.runtime_supported);
+        assert_eq!(first.source.dependencies.len(), 1);
+        assert_eq!(first.skeletons.len(), 1);
+        assert_eq!(first.clips.len(), 1);
+        assert_eq!(first.skeletons[0].id, "animation:skeleton:0:hero_rig");
+        assert!(!first.skeletons[0].signature.is_empty());
+        assert_eq!(first.clips[0].id, "animation:clip:0:idle_loop");
+        assert_eq!(first.clips[0].duration_seconds, 1.25);
+        assert_eq!(
+            first.clips[0].target_skeleton_signature,
+            Some(first.skeletons[0].signature.clone())
+        );
+        assert_eq!(first.clips[0].events.len(), 1);
+        assert_eq!(first.clips[0].events[0].id, "footstep.left");
+        assert_eq!(first.clips[0].events[0].time_seconds, 0.5);
+        assert_eq!(first.diagnostics, Vec::new());
+
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn exact_signature_changes_with_joint_path_or_bind_pose() {
+        let identity = identity_matrix_bytes();
+        let first = skeleton_signature(
+            &[vec!["Armature".into(), "Hip".into()]],
+            std::slice::from_ref(&identity),
+        );
+        let renamed = skeleton_signature(
+            &[vec!["Armature".into(), "Pelvis".into()]],
+            std::slice::from_ref(&identity),
+        );
+        let mut changed_pose = identity;
+        changed_pose[0] ^= 1;
+        let rebound = skeleton_signature(&[vec!["Armature".into(), "Hip".into()]], &[changed_pose]);
+        assert_ne!(first, renamed);
+        assert_ne!(first, rebound);
+    }
+
+    #[test]
+    fn exact_signature_preserves_bevy_node_bytes_and_segment_boundaries() {
+        let identity = identity_matrix_bytes();
+        let slash_in_name = vec![vec!["Armature".into(), "Hip/Joint".into()]];
+        let slash_as_boundary = vec![vec!["Armature/Hip".into(), "Joint".into()]];
+
+        assert_eq!(slash_in_name[0].join("/"), slash_as_boundary[0].join("/"));
+        assert_ne!(
+            skeleton_signature(&slash_in_name, std::slice::from_ref(&identity)),
+            skeleton_signature(&slash_as_boundary, std::slice::from_ref(&identity))
+        );
+
+        let backslash = vec![vec!["Armature".into(), "Hip\\Joint".into()]];
+        assert_eq!(
+            normalized_node_segment(Some("Hip/Joint"), 1),
+            normalized_node_segment(Some("Hip\\Joint"), 1)
+        );
+        assert_ne!(
+            skeleton_signature(&slash_in_name, std::slice::from_ref(&identity)),
+            skeleton_signature(&backslash, std::slice::from_ref(&identity))
+        );
+        assert_eq!(bevy_node_segment(Some("  /Joint  "), 7), "  /Joint  ");
+        assert_eq!(bevy_node_segment(None, 7), "GltfNode7");
+    }
+
+    #[test]
+    fn gltf_with_multiple_animation_roots_is_runtime_unsupported() {
+        let root =
+            std::env::temp_dir().join(format!("blacksite-animation-multi-root-{}", Uuid::new_v4()));
+        let path = write_multi_root_animated_gltf(&root);
+        let manifest = build_animation_manifest(&fixture_record(&path)).unwrap();
+
+        assert!(!manifest.runtime_supported);
+        let diagnostic = manifest
+            .diagnostics
+            .iter()
+            .find(|diagnostic| diagnostic.code == "animation.multiple_roots_unsupported")
+            .expect("multi-root glTF should include an actionable blocking diagnostic");
+        assert_eq!(diagnostic.severity, AnimationDiagnosticSeverity::Error);
+        assert!(diagnostic.message.contains("2 distinct top-level roots"));
+        assert!(diagnostic.repair.contains("one common top-level root"));
+
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn animated_or_skinned_fbx_is_runtime_unsupported_with_repair_guidance() {
+        let (supported, diagnostics) = fbx_runtime_support(2, 1);
+        assert!(!supported);
+        assert_eq!(diagnostics.len(), 1);
+        assert_eq!(diagnostics[0].severity, AnimationDiagnosticSeverity::Error);
+        assert_eq!(diagnostics[0].code, "animation.fbx_runtime_unsupported");
+        assert!(diagnostics[0].repair.contains("glTF 2.0"));
+
+        let (supported, diagnostics) = fbx_runtime_support(0, 0);
+        assert!(!supported);
+        assert!(diagnostics.is_empty());
+    }
+
+    #[test]
+    fn committed_robot_fixture_exposes_a_skin_and_multiple_named_states() {
+        let path =
+            Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/models/robot_expressive.glb");
+        let manifest = build_animation_manifest(&fixture_record(&path)).unwrap();
+
+        assert!(manifest.runtime_supported);
+        assert_eq!(manifest.skeletons.len(), 2);
+        assert_eq!(manifest.skeletons[0].id, "animation:skeleton:0:skeleton_0");
+        assert_eq!(manifest.skeletons[1].id, "animation:skeleton:1:skeleton_1");
+        assert!(manifest
+            .skeletons
+            .iter()
+            .all(|skeleton| skeleton.joint_paths.len() == 43));
+        let signature = &manifest.skeletons[0].signature;
+        assert!(manifest
+            .skeletons
+            .iter()
+            .all(|skeleton| &skeleton.signature == signature));
+        assert_eq!(manifest.clips.len(), 14);
+        for expected in ["Idle", "Walking", "Running", "Jump", "Wave"] {
+            assert!(
+                manifest.clips.iter().any(|clip| clip.label == expected),
+                "missing expected fixture clip {expected}"
+            );
+        }
+        assert!(manifest
+            .clips
+            .iter()
+            .all(|clip| clip.duration_seconds.is_finite() && clip.duration_seconds > 0.0));
+        assert!(manifest
+            .clips
+            .iter()
+            .all(|clip| { clip.target_skeleton_signature.as_ref() == Some(signature) }));
+        assert!(manifest.diagnostics.is_empty());
+    }
+}
diff --git a/crates/editor/src/assets/asset_db.rs b/crates/editor/src/assets/asset_db.rs
index 847d2f9..3f75e7d 100644
--- a/crates/editor/src/assets/asset_db.rs
+++ b/crates/editor/src/assets/asset_db.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use uuid::Uuid;
 
 /// Stable asset identity for dependency tracking and prefab references.
@@ -59,6 +59,8 @@ pub struct ImportSettings {
     pub material_policy: MaterialImportPolicy,
     #[serde(default)]
     pub static_mesh_manifest_path: Option<String>,
+    #[serde(default)]
+    pub animation_manifest_path: Option<String>,
 }
 
 impl Default for ImportSettings {
@@ -71,6 +73,7 @@ impl Default for ImportSettings {
             hierarchy_mode: ModelHierarchyMode::default(),
             material_policy: MaterialImportPolicy::default(),
             static_mesh_manifest_path: None,
+            animation_manifest_path: None,
         }
     }
 }
@@ -115,6 +118,11 @@ fn sync_registry_from_browser(
         .drain(..)
         .map(|record| (record.path.clone(), record))
         .collect();
+    let current_paths = assets
+        .assets
+        .iter()
+        .filter_map(|asset| asset.path.clone())
+        .collect::<HashSet<_>>();
 
     let mut next_records = Vec::new();
     let mut seen_paths = HashMap::new();
@@ -129,7 +137,18 @@ fn sync_registry_from_browser(
         seen_paths.insert(path.clone(), ());
 
         let kind_tag = format!("{:?}", asset.kind);
-        let mut record = if let Some(mut prior) = existing.remove(&path) {
+        let mut record = if let Some(mut prior) = existing.remove(&path).or_else(|| {
+            take_uniquely_moved_model_record(&mut existing, &current_paths, &path, &kind_tag)
+        }) {
+            if prior.path != path {
+                info!(
+                    "Asset registry preserved model identity {} across move {} -> {}",
+                    prior.id.as_string(),
+                    prior.path,
+                    path
+                );
+                prior.path = path.clone();
+            }
             prior.label = asset.label.clone();
             prior.kind_tag = kind_tag;
             prior
@@ -144,9 +163,9 @@ fn sync_registry_from_browser(
             }
         };
         if record.kind_tag == "Model" {
-            if let Err(error) = super::static_mesh::refresh_static_mesh_artifact(&mut record) {
+            if let Err(error) = super::refresh_model_artifacts(&mut record) {
                 warn!(
-                    "Static mesh processor failed for {} (asset id {}): {error}",
+                    "Model artifact refresh failed for {} (asset id {}): {error}",
                     record.path,
                     record.id.as_string()
                 );
@@ -170,6 +189,34 @@ fn sync_registry_from_browser(
     }
 }
 
+fn take_uniquely_moved_model_record(
+    existing: &mut HashMap<String, AssetRecord>,
+    current_paths: &HashSet<String>,
+    new_path: &str,
+    kind_tag: &str,
+) -> Option<AssetRecord> {
+    if kind_tag != "Model" {
+        return None;
+    }
+    let bytes = std::fs::read(new_path).ok()?;
+    let content_hash = blake3::hash(&bytes).to_hex().to_string();
+    let candidates = existing
+        .iter()
+        .filter_map(|(old_path, record)| {
+            if current_paths.contains(old_path) || record.kind_tag != "Model" {
+                return None;
+            }
+            let manifest_path = record.import_settings.animation_manifest_path.as_deref()?;
+            let manifest = super::animation::load_animation_manifest(manifest_path).ok()?;
+            (manifest.source.fingerprint.content_hash == content_hash).then(|| old_path.clone())
+        })
+        .collect::<Vec<_>>();
+    if candidates.len() != 1 {
+        return None;
+    }
+    existing.remove(&candidates[0])
+}
+
 pub fn find_asset_by_path(registry: &AssetRegistry, path: &str) -> Option<AssetRecord> {
     registry
         .records
@@ -196,6 +243,34 @@ pub fn find_asset_mut_by_path<'a>(
         .find(|record| record.path == path)
 }
 
+pub fn ensure_asset_record(
+    registry: &mut AssetRegistry,
+    path: impl Into<String>,
+    label: impl Into<String>,
+    kind_tag: impl Into<String>,
+) -> Result<AssetRecord, String> {
+    let path = path.into();
+    if let Some(record) = find_asset_by_path(registry, &path) {
+        return Ok(record);
+    }
+    let record = AssetRecord {
+        id: AssetId::new(),
+        path,
+        label: label.into(),
+        kind_tag: kind_tag.into(),
+        import_settings: ImportSettings::default(),
+        dependencies: Vec::new(),
+    };
+    registry.records.push(record.clone());
+    registry.index_dirty = true;
+    if let Err(error) = save_registry(registry) {
+        registry.records.pop();
+        return Err(error);
+    }
+    registry.index_dirty = false;
+    Ok(record)
+}
+
 pub fn update_import_settings(
     registry: &mut AssetRegistry,
     path: &str,
@@ -240,3 +315,98 @@ pub fn load_registry() -> AssetRegistry {
         Err(_) => AssetRegistry::default(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use shared::{
+        AnimationManifest, AnimationManifestSource, AnimationSourceFingerprint,
+        ANIMATION_MANIFEST_SCHEMA_VERSION,
+    };
+
+    fn moved_model_fixture(bytes: &[u8]) -> (std::path::PathBuf, std::path::PathBuf, AssetRecord) {
+        let key = Uuid::new_v4();
+        let source_path = std::env::temp_dir().join(format!("blacksite-moved-model-{key}.glb"));
+        let manifest_path =
+            std::env::temp_dir().join(format!("blacksite-moved-model-{key}.animation.ron"));
+        std::fs::write(&source_path, bytes).unwrap();
+        let id = AssetId::new();
+        let old_path = format!("assets/models/old-{key}.glb");
+        let manifest = AnimationManifest {
+            schema_version: ANIMATION_MANIFEST_SCHEMA_VERSION,
+            asset_id: id.as_string(),
+            label: "Moved Model".into(),
+            source: AnimationManifestSource {
+                path: old_path.clone(),
+                format: "glb".into(),
+                fingerprint: AnimationSourceFingerprint {
+                    byte_len: bytes.len() as u64,
+                    modified_unix_secs: 0,
+                    content_hash: blake3::hash(bytes).to_hex().to_string(),
+                },
+                dependencies: Vec::new(),
+            },
+            runtime_supported: true,
+            skeletons: Vec::new(),
+            clips: Vec::new(),
+            diagnostics: Vec::new(),
+        };
+        std::fs::write(
+            &manifest_path,
+            ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default()).unwrap(),
+        )
+        .unwrap();
+        let record = AssetRecord {
+            id,
+            path: old_path,
+            label: "Moved Model".into(),
+            kind_tag: "Model".into(),
+            import_settings: ImportSettings {
+                animation_manifest_path: Some(manifest_path.to_string_lossy().into_owned()),
+                ..Default::default()
+            },
+            dependencies: Vec::new(),
+        };
+        (source_path, manifest_path, record)
+    }
+
+    #[test]
+    fn unique_content_match_preserves_model_record_across_move() {
+        let (source_path, manifest_path, record) = moved_model_fixture(b"stable model bytes");
+        let expected_id = record.id.clone();
+        let mut existing = HashMap::from([(record.path.clone(), record)]);
+
+        let moved = take_uniquely_moved_model_record(
+            &mut existing,
+            &HashSet::new(),
+            &source_path.to_string_lossy(),
+            "Model",
+        )
+        .expect("unique moved model should retain its registry record");
+
+        assert_eq!(moved.id, expected_id);
+        assert!(existing.is_empty());
+        let _ = std::fs::remove_file(source_path);
+        let _ = std::fs::remove_file(manifest_path);
+    }
+
+    #[test]
+    fn existing_source_path_is_not_reconciled_as_a_copy_move() {
+        let (source_path, manifest_path, record) = moved_model_fixture(b"copied model bytes");
+        let old_path = record.path.clone();
+        let mut existing = HashMap::from([(old_path.clone(), record)]);
+        let current_paths = HashSet::from([old_path]);
+
+        let moved = take_uniquely_moved_model_record(
+            &mut existing,
+            &current_paths,
+            &source_path.to_string_lossy(),
+            "Model",
+        );
+
+        assert!(moved.is_none());
+        assert_eq!(existing.len(), 1);
+        let _ = std::fs::remove_file(source_path);
+        let _ = std::fs::remove_file(manifest_path);
+    }
+}
diff --git a/crates/editor/src/assets/catalog.rs b/crates/editor/src/assets/catalog.rs
index fa0433e..f49e961 100644
--- a/crates/editor/src/assets/catalog.rs
+++ b/crates/editor/src/assets/catalog.rs
@@ -5,28 +5,34 @@ use bevy::prelude::*;
 use settings::ProjectSettings;
 use shared::{
     ActorKind, AuthoringLightKind, ColliderDesc, ColorDesc, EditorVisibility, LightDesc,
-    MaterialDesc, ModelRef, PostProcessVolumeDesc, PrefabInstance, PrefabRef, Primitive,
-    PrimitiveShape, RigidBodyDesc,
+    MaterialDesc, ModelRef, PostProcessVolumeDesc, PrefabRef, Primitive, PrimitiveShape,
+    RigidBodyDesc, AUDIO_CLIP_SUB_ASSET_ID,
 };
 use walkdir::WalkDir;
 
 use crate::asset_db::{
-    find_asset_by_path, find_asset_mut_by_path, AssetRegistry, MaterialImportPolicy,
-    ModelPlacementMode,
-};
-use crate::assets::static_mesh::{
-    load_static_mesh_manifest, refresh_static_mesh_artifact, renderer_from_manifest,
+    ensure_asset_record, find_asset_by_id, find_asset_by_path, find_asset_mut_by_path,
+    AssetRegistry, MaterialImportPolicy, ModelPlacementMode,
 };
+use crate::assets::animation::load_animation_manifest;
+use crate::assets::static_mesh::{load_static_mesh_manifest, renderer_from_manifest};
 use crate::history::{spawn_with_history, EditorEntitySnapshot};
 
 pub const BUILTINS_FOLDER: &str = "__builtins__";
 pub const ASSETS_ROOT: &str = "assets";
+pub const AUDIO_ASSET_EXTENSIONS: &[&str] = &["ogg", "oga", "spx", "wav", "mp3", "flac"];
+pub const IMPORTABLE_ASSET_EXTENSIONS: &[&str] = &[
+    "gltf", "glb", "fbx", "png", "jpg", "jpeg", "webp", "ktx2", "ogg", "oga", "spx", "wav", "mp3",
+    "flac",
+];
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum AssetSubAssetKind {
     Mesh,
     Material,
     Texture,
+    Skeleton,
+    AnimationClip,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -73,6 +79,7 @@ pub enum EditorAssetKind {
     Model,
     Texture,
     Material,
+    AudioClip,
     Level,
     Prefab,
     PostProcessVolume,
@@ -219,7 +226,15 @@ pub struct EditorAssetsPlugin;
 impl Plugin for EditorAssetsPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<EditorAssets>()
-            .add_systems(Update, refresh_assets_on_settings_change);
+            .init_resource::<super::prefab_overrides::PrefabHealthCache>()
+            .add_observer(super::prefab_overrides::invalidate_prefab_health_on_ready)
+            .add_systems(
+                Update,
+                (
+                    refresh_assets_on_settings_change,
+                    super::prefab_overrides::guard_prefab_reimports,
+                ),
+            );
     }
 }
 
@@ -352,50 +367,56 @@ fn should_skip_asset_path(path: &Path) -> bool {
 
 fn asset_from_file_path(path: &Path) -> Option<EditorAsset> {
     let extension = path.extension()?.to_str()?.to_ascii_lowercase();
-    let (kinds, extensions) = match extension.as_str() {
-        "gltf" | "glb" | "fbx" => (vec![EditorAssetKind::Model], vec!["gltf", "glb", "fbx"]),
-        "png" | "jpg" | "jpeg" | "webp" | "ktx2" => (
-            vec![EditorAssetKind::Texture],
-            vec!["png", "jpg", "jpeg", "webp", "ktx2"],
-        ),
-        "ron" | "mat" | "material" => {
-            if path.to_string_lossy().contains("/materials/") {
-                (
-                    vec![EditorAssetKind::Material],
-                    vec!["ron", "mat", "material"],
-                )
-            } else if path.to_string_lossy().contains("/post_fx/") {
-                (vec![EditorAssetKind::PostProcessEffect], vec!["ron"])
-            } else if path.to_string_lossy().contains("/rendering_profiles/") {
-                (vec![EditorAssetKind::RenderingProfile], vec!["ron"])
-            } else if path.to_string_lossy().contains("/shaders/") {
-                (vec![EditorAssetKind::ShaderSchema], vec!["ron"])
-            } else {
-                (
-                    vec![EditorAssetKind::Level, EditorAssetKind::Prefab],
-                    vec!["ron"],
-                )
+    let normalized_path = normalize_asset_path(path);
+    let (kinds, extensions) = if is_audio_asset_extension(&extension) {
+        (
+            vec![EditorAssetKind::AudioClip],
+            AUDIO_ASSET_EXTENSIONS.to_vec(),
+        )
+    } else {
+        match extension.as_str() {
+            "gltf" | "glb" | "fbx" => (vec![EditorAssetKind::Model], vec!["gltf", "glb", "fbx"]),
+            "png" | "jpg" | "jpeg" | "webp" | "ktx2" => (
+                vec![EditorAssetKind::Texture],
+                vec!["png", "jpg", "jpeg", "webp", "ktx2"],
+            ),
+            "ron" | "mat" | "material" => {
+                if normalized_path.contains("/materials/") {
+                    (
+                        vec![EditorAssetKind::Material],
+                        vec!["ron", "mat", "material"],
+                    )
+                } else if normalized_path.contains("/post_fx/") {
+                    (vec![EditorAssetKind::PostProcessEffect], vec!["ron"])
+                } else if normalized_path.contains("/rendering_profiles/") {
+                    (vec![EditorAssetKind::RenderingProfile], vec!["ron"])
+                } else if normalized_path.contains("/shaders/") {
+                    (vec![EditorAssetKind::ShaderSchema], vec!["ron"])
+                } else if normalized_path.ends_with(".scn.ron")
+                    && (normalized_path.starts_with("assets/prefabs/")
+                        || normalized_path.contains("/assets/prefabs/"))
+                {
+                    (vec![EditorAssetKind::Prefab], vec!["ron"])
+                } else {
+                    (vec![EditorAssetKind::Level], vec!["ron"])
+                }
             }
+            _ => return None,
         }
-        _ => return None,
     };
 
     if !has_extension(path, &extensions) {
         return None;
     }
 
-    let path_string = normalize_asset_path(path);
+    let path_string = normalized_path;
     let folder_path = parent_folder_path(&path_string).unwrap_or_else(|| ASSETS_ROOT.to_string());
     let label = path
         .file_stem()
         .and_then(|stem| stem.to_str())
         .unwrap_or(&path_string)
         .to_string();
-    let kind = if kinds.len() == 2 && path_string.ends_with(".scn.ron") {
-        kinds[1].clone()
-    } else {
-        kinds[0].clone()
-    };
+    let kind = kinds[0].clone();
 
     Some(EditorAsset {
         label,
@@ -447,8 +468,54 @@ fn has_extension(path: &Path, extensions: &[&str]) -> bool {
         })
 }
 
-pub fn snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> Option<EditorEntitySnapshot> {
-    let mut snapshot = EditorEntitySnapshot {
+fn is_audio_asset_extension(extension: &str) -> bool {
+    AUDIO_ASSET_EXTENSIONS
+        .iter()
+        .any(|candidate| extension.eq_ignore_ascii_case(candidate))
+}
+
+pub fn audio_clip_ref_for_asset(
+    world: &mut World,
+    asset: &EditorAsset,
+) -> Result<shared::EditorAssetRef, String> {
+    if !matches!(asset.kind, EditorAssetKind::AudioClip) {
+        return Err(format!("{} is not an audio clip", asset.label));
+    }
+    let path = asset
+        .path
+        .as_deref()
+        .ok_or_else(|| format!("audio clip {} has no source path", asset.label))?;
+    let record = world
+        .get_resource_mut::<AssetRegistry>()
+        .ok_or_else(|| "asset registry is unavailable".to_string())
+        .and_then(|mut registry| {
+            ensure_asset_record(
+                &mut registry,
+                path.to_string(),
+                asset.label.clone(),
+                "AudioClip",
+            )
+        })?;
+    Ok(shared::EditorAssetRef::new(
+        record.id.as_string(),
+        AUDIO_CLIP_SUB_ASSET_ID,
+        asset.label.clone(),
+    )
+    .with_source_path(path))
+}
+
+pub fn audio_source_desc_for_asset(
+    world: &mut World,
+    asset: &EditorAsset,
+) -> Result<shared::AudioSourceDesc, String> {
+    Ok(shared::AudioSourceDesc {
+        clip: Some(audio_clip_ref_for_asset(world, asset)?),
+        ..Default::default()
+    })
+}
+
+fn empty_snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> EditorEntitySnapshot {
+    EditorEntitySnapshot {
         actor_id: None,
         actor_kind: ActorKind::Empty,
         actor_name: None,
@@ -463,6 +530,9 @@ pub fn snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> Option<Edit
         collider: None,
         physics: None,
         light: None,
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
@@ -475,7 +545,11 @@ pub fn snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> Option<Edit
         hierarchy_sibling_index: 0,
         editor_visibility: EditorVisibility::default(),
         children: Vec::new(),
-    };
+    }
+}
+
+pub fn snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> Option<EditorEntitySnapshot> {
+    let mut snapshot = empty_snapshot_for_asset(asset, translation);
 
     match &asset.kind {
         EditorAssetKind::Primitive(shape) => {
@@ -522,13 +596,15 @@ pub fn snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> Option<Edit
             snapshot.model = Some(ModelRef::new(path.clone()));
             snapshot.transform.translation.y += 0.1;
         }
-        EditorAssetKind::Prefab | EditorAssetKind::Level => {
+        EditorAssetKind::Prefab => {
             snapshot.actor_kind = ActorKind::PrefabAnchor;
             let path = asset.path.as_ref()?;
             snapshot.prefab = Some(PrefabRef::new(path.clone()));
         }
+        EditorAssetKind::Level => return None,
         EditorAssetKind::Texture
         | EditorAssetKind::Material
+        | EditorAssetKind::AudioClip
         | EditorAssetKind::PostProcessEffect
         | EditorAssetKind::RenderingProfile
         | EditorAssetKind::ShaderSchema => return None,
@@ -538,7 +614,24 @@ pub fn snapshot_for_asset(asset: &EditorAsset, translation: Vec3) -> Option<Edit
 }
 
 pub fn spawn_asset_at(world: &mut World, asset: &EditorAsset, translation: Vec3) -> Option<Entity> {
-    let mut snapshot = snapshot_for_asset(asset, translation)?;
+    let mut snapshot = if matches!(asset.kind, EditorAssetKind::AudioClip) {
+        let descriptor = match audio_source_desc_for_asset(world, asset) {
+            Ok(descriptor) => descriptor,
+            Err(error) => {
+                warn!("Audio clip placement failed for {}: {error}", asset.label);
+                if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
+                    scene_io.status = format!("Audio placement failed: {error}");
+                }
+                return None;
+            }
+        };
+        let mut snapshot = empty_snapshot_for_asset(asset, translation);
+        snapshot.actor_kind = ActorKind::AudioSource;
+        snapshot.audio_source = Some(descriptor);
+        snapshot
+    } else {
+        snapshot_for_asset(asset, translation)?
+    };
     if let Some(light) = snapshot.light.as_mut() {
         if matches!(light.kind, AuthoringLightKind::Directional) {
             light.intensity = world
@@ -548,12 +641,32 @@ pub fn spawn_asset_at(world: &mut World, asset: &EditorAsset, translation: Vec3)
         }
     }
     if let Some(path) = asset.path.as_ref() {
-        let record = world
+        let mut record = world
             .get_resource::<AssetRegistry>()
             .and_then(|registry| find_asset_by_path(registry, path));
+        if matches!(asset.kind, EditorAssetKind::Prefab) && record.is_none() {
+            record = world
+                .get_resource_mut::<AssetRegistry>()
+                .and_then(|mut registry| {
+                    ensure_asset_record(&mut registry, path.clone(), asset.label.clone(), "Prefab")
+                        .map_err(|error| {
+                            error!("Could not register prefab asset {path}: {error}");
+                        })
+                        .ok()
+                });
+        }
+        if matches!(asset.kind, EditorAssetKind::Prefab) && record.is_none() {
+            if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
+                scene_io.status = format!("Prefab placement failed: could not register {path}");
+            }
+            return None;
+        }
         if let Some(record) = record {
             match asset.kind {
                 EditorAssetKind::Model => {
+                    if let Some(model) = snapshot.model.as_mut() {
+                        model.asset_id = record.id.as_string();
+                    }
                     snapshot.transform.scale *= record.import_settings.scale;
                     if matches!(
                         record.import_settings.placement_mode,
@@ -580,7 +693,11 @@ pub fn spawn_asset_at(world: &mut World, asset: &EditorAsset, translation: Vec3)
                 }
                 EditorAssetKind::Prefab => {
                     snapshot.prefab_instance =
-                        Some(PrefabInstance::new(record.id.as_string(), path.clone()));
+                        Some(super::prefab_overrides::new_tracked_prefab_instance(
+                            world,
+                            record.id.as_string(),
+                            path.clone(),
+                        ));
                 }
                 _ => {}
             }
@@ -589,11 +706,37 @@ pub fn spawn_asset_at(world: &mut World, asset: &EditorAsset, translation: Vec3)
     Some(spawn_with_history(world, snapshot))
 }
 
+pub fn validate_prefab_asset(world: &World, asset: &EditorAsset) -> Result<(), String> {
+    if !matches!(asset.kind, EditorAssetKind::Prefab) {
+        return Ok(());
+    }
+    let source_path = asset
+        .path
+        .as_deref()
+        .ok_or_else(|| "Prefab asset has no source path".to_string())?;
+    let project_root = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+        .ok_or_else(|| "Project workspace is unavailable".to_string())?;
+    scene::validate_prefab_graph(&project_root.join(source_path), &project_root)
+        .map_err(|error| format!("Prefab dependency validation failed: {error}"))
+}
+
 pub fn spawn_subasset_at(
     world: &mut World,
     selection: &AssetSelection,
     translation: Vec3,
 ) -> Option<Entity> {
+    if matches!(
+        selection,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::AnimationClip,
+            ..
+        }
+    ) {
+        return spawn_animation_clip_at(world, selection, translation);
+    }
+
     let AssetSelection::SubAsset {
         parent_path,
         sub_asset_id,
@@ -663,6 +806,9 @@ pub fn spawn_subasset_at(
         collider: None,
         physics: None,
         light: None,
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
@@ -685,6 +831,251 @@ pub fn spawn_subasset_at(
     Some(spawn_with_history(world, snapshot))
 }
 
+#[derive(Debug, Clone)]
+pub struct AnimationClipAuthoringData {
+    pub model_asset_id: String,
+    pub model_path: String,
+    pub model_label: String,
+    pub model_scale: f32,
+    pub skeleton: shared::EditorAssetRef,
+    pub skeleton_signature: shared::AnimationSkeletonSignature,
+    pub state: shared::AnimationStateDesc,
+}
+
+pub fn animation_clip_authoring_data(
+    world: &World,
+    selection: &AssetSelection,
+) -> Result<AnimationClipAuthoringData, String> {
+    let AssetSelection::SubAsset {
+        parent_path,
+        sub_asset_id,
+        kind: AssetSubAssetKind::AnimationClip,
+        ..
+    } = selection
+    else {
+        return Err("the selected sub-asset is not an animation clip".into());
+    };
+    let record = world
+        .get_resource::<AssetRegistry>()
+        .and_then(|registry| find_asset_by_path(registry, parent_path))
+        .ok_or_else(|| format!("model `{parent_path}` is missing from the asset registry"))?;
+    let manifest_path = record
+        .import_settings
+        .animation_manifest_path
+        .as_deref()
+        .ok_or_else(|| format!("model `{parent_path}` has no generated animation manifest"))?;
+    let manifest = load_animation_manifest(manifest_path)?;
+    if !manifest.runtime_supported {
+        return Err(format!(
+            "model `{parent_path}` is not supported by the animation runtime; animation v1 requires glTF/GLB"
+        ));
+    }
+    let clip = manifest
+        .clips
+        .iter()
+        .find(|clip| clip.id == *sub_asset_id)
+        .ok_or_else(|| {
+            format!(
+                "animation clip `{sub_asset_id}` is missing from `{manifest_path}`; reimport the model"
+            )
+        })?;
+    let target_signature = clip.target_skeleton_signature.as_ref().ok_or_else(|| {
+        format!(
+            "animation clip `{}` has no uniquely resolved target skeleton",
+            clip.label
+        )
+    })?;
+    let skeleton = manifest
+        .skeletons
+        .iter()
+        .find(|skeleton| &skeleton.signature == target_signature)
+        .ok_or_else(|| {
+            format!(
+                "animation clip `{}` targets skeleton `{}` but no exact match exists in `{parent_path}`",
+                clip.label, target_signature.0
+            )
+        })?;
+    let asset_id = record.id.as_string();
+    let skeleton_ref = shared::EditorAssetRef::new(
+        asset_id.clone(),
+        skeleton.id.clone(),
+        skeleton.label.clone(),
+    )
+    .with_source_path(parent_path);
+    let clip_ref = shared::EditorAssetRef::new(asset_id, clip.id.clone(), clip.label.clone())
+        .with_source_path(parent_path);
+    let state_id = animation_state_id(&clip.label, clip.source_index);
+    Ok(AnimationClipAuthoringData {
+        model_asset_id: record.id.as_string(),
+        model_path: parent_path.clone(),
+        model_label: record.label,
+        model_scale: record.import_settings.scale,
+        skeleton: skeleton_ref,
+        skeleton_signature: skeleton.signature.clone(),
+        state: shared::AnimationStateDesc {
+            id: state_id,
+            label: clip.label.clone(),
+            clip: clip_ref,
+            looping: true,
+            speed: 1.0,
+            range: shared::AnimationPlaybackRange::default(),
+        },
+    })
+}
+
+pub fn animation_skeleton_signature_for_ref(
+    world: &World,
+    reference: &shared::EditorAssetRef,
+) -> Result<shared::AnimationSkeletonSignature, String> {
+    let record = world
+        .get_resource::<AssetRegistry>()
+        .and_then(|registry| find_asset_by_id(registry, &reference.asset_id))
+        .ok_or_else(|| {
+            format!(
+                "skeleton asset `{}` is missing from the asset registry",
+                reference.asset_id
+            )
+        })?;
+    let manifest_path = record
+        .import_settings
+        .animation_manifest_path
+        .as_deref()
+        .ok_or_else(|| format!("model `{}` has no animation manifest", record.path))?;
+    let manifest = load_animation_manifest(manifest_path)?;
+    manifest
+        .skeletons
+        .iter()
+        .find(|skeleton| skeleton.id == reference.sub_asset_id)
+        .map(|skeleton| skeleton.signature.clone())
+        .ok_or_else(|| {
+            format!(
+                "skeleton `{}` is missing from `{manifest_path}`; reimport the model",
+                reference.sub_asset_id
+            )
+        })
+}
+
+pub fn compatible_animation_skeleton_for_model(
+    world: &World,
+    model: &ModelRef,
+    signature: &shared::AnimationSkeletonSignature,
+) -> Result<shared::EditorAssetRef, String> {
+    let record = world
+        .get_resource::<AssetRegistry>()
+        .and_then(|registry| {
+            if model.asset_id.trim().is_empty() {
+                find_asset_by_path(registry, &model.path)
+            } else {
+                find_asset_by_id(registry, &model.asset_id)
+            }
+        })
+        .ok_or_else(|| {
+            format!(
+                "model `{}` ({}) is missing from the asset registry",
+                model.path, model.asset_id
+            )
+        })?;
+    let model_path = record.path.as_str();
+    let manifest_path = record
+        .import_settings
+        .animation_manifest_path
+        .as_deref()
+        .ok_or_else(|| format!("model `{model_path}` has no animation manifest"))?;
+    let manifest = load_animation_manifest(manifest_path)?;
+    let skeleton = manifest
+        .skeletons
+        .iter()
+        .find(|skeleton| &skeleton.signature == signature)
+        .ok_or_else(|| {
+            format!(
+                "model `{model_path}` has no skeleton matching animation rig `{}`",
+                signature.0
+            )
+        })?;
+    Ok(shared::EditorAssetRef::new(
+        record.id.as_string(),
+        skeleton.id.clone(),
+        skeleton.label.clone(),
+    )
+    .with_source_path(model_path))
+}
+
+fn animation_state_id(label: &str, source_index: usize) -> String {
+    let mut id = String::new();
+    for character in label.chars() {
+        if character.is_ascii_alphanumeric() {
+            id.push(character.to_ascii_lowercase());
+        } else if !id.ends_with('_') {
+            id.push('_');
+        }
+    }
+    let id = id.trim_matches('_');
+    if id.is_empty() {
+        format!("clip_{source_index}")
+    } else {
+        id.to_string()
+    }
+}
+
+fn spawn_animation_clip_at(
+    world: &mut World,
+    selection: &AssetSelection,
+    translation: Vec3,
+) -> Option<Entity> {
+    let authored = match animation_clip_authoring_data(world, selection) {
+        Ok(authored) => authored,
+        Err(error) => {
+            warn!("Animation clip placement failed: {error}");
+            if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
+                scene_io.status = format!("Animation placement failed: {error}");
+            }
+            return None;
+        }
+    };
+    let default_state = authored.state.id.clone();
+    let snapshot = EditorEntitySnapshot {
+        actor_id: None,
+        actor_kind: ActorKind::ImportedModel,
+        actor_name: None,
+        name: Some(authored.model_label),
+        transform: Transform {
+            translation: translation + Vec3::Y * 0.1,
+            scale: Vec3::splat(authored.model_scale),
+            ..default()
+        },
+        primitive: None,
+        brush: None,
+        static_mesh_renderer: None,
+        material: None,
+        material_override: None,
+        rigid_body: None,
+        collider: None,
+        physics: None,
+        light: None,
+        animation_controller: Some(shared::AnimationControllerDesc {
+            skeleton: Some(authored.skeleton),
+            states: vec![authored.state],
+            default_state,
+            ..default()
+        }),
+        audio_source: None,
+        audio_listener: None,
+        player_spawn: false,
+        model: Some(ModelRef::new(authored.model_path).with_asset_id(authored.model_asset_id)),
+        prefab: None,
+        prefab_instance: None,
+        weapon_spawn: None,
+        trigger_volume: None,
+        post_process_volume: None,
+        team_spawn: None,
+        objective: None,
+        hierarchy_sibling_index: 0,
+        editor_visibility: EditorVisibility::default(),
+        children: Vec::new(),
+    };
+    Some(spawn_with_history(world, snapshot))
+}
+
 fn apply_static_mesh_placement_mode(
     snapshot: &mut EditorEntitySnapshot,
     renderer: shared::StaticMeshRenderer,
@@ -733,6 +1124,9 @@ fn apply_static_mesh_placement_mode(
                         collider,
                         physics: None,
                         light: None,
+                        animation_controller: None,
+                        audio_source: None,
+                        audio_listener: None,
                         player_spawn: false,
                         model: None,
                         prefab: None,
@@ -788,13 +1182,13 @@ fn static_mesh_renderer_for_asset(
     if let Some(mut registry) = world.get_resource_mut::<AssetRegistry>() {
         let mut renderer = None;
         if let Some(record) = find_asset_mut_by_path(&mut registry, path) {
-            match refresh_static_mesh_artifact(record) {
+            match super::refresh_model_artifacts(record) {
                 Ok(manifest) => {
                     renderer = Some(renderer_from_manifest(&manifest, &record.import_settings));
                     registry.index_dirty = true;
                 }
                 Err(error) => {
-                    warn!("Static mesh manifest refresh failed for {path}: {error}");
+                    warn!("Model artifact refresh failed for {path}: {error}");
                     manifest_path = record.import_settings.static_mesh_manifest_path.clone();
                 }
             }
@@ -847,6 +1241,9 @@ pub fn import_external_assets(paths: &[PathBuf]) -> Result<usize, String> {
 }
 
 fn import_dir_for_extension(extension: &str) -> &'static str {
+    if is_audio_asset_extension(extension) {
+        return "assets/audio";
+    }
     match extension.to_ascii_lowercase().as_str() {
         "gltf" | "glb" | "fbx" => "assets/models",
         "png" | "jpg" | "jpeg" | "webp" | "ktx2" => "assets/textures",
@@ -870,3 +1267,85 @@ pub fn asset_cache_key(asset: &EditorAsset) -> String {
         None => format!("builtin:{}", asset.label),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::asset_db::{AssetId, AssetRecord};
+    use uuid::Uuid;
+
+    #[test]
+    fn scene_assets_are_classified_by_authoring_folder() {
+        let level = asset_from_file_path(Path::new("assets/levels/arena.scn.ron")).unwrap();
+        let prefab = asset_from_file_path(Path::new("assets/prefabs/crate.scn.ron")).unwrap();
+
+        assert_eq!(level.kind, EditorAssetKind::Level);
+        assert_eq!(prefab.kind, EditorAssetKind::Prefab);
+    }
+
+    #[test]
+    fn bevy_audio_extensions_are_classified_and_imported_to_audio() {
+        for extension in AUDIO_ASSET_EXTENSIONS {
+            let path = format!("assets/audio/impact.{extension}");
+            let asset = asset_from_file_path(Path::new(&path)).unwrap();
+            assert_eq!(asset.kind, EditorAssetKind::AudioClip);
+            assert_eq!(asset.folder_path, "assets/audio");
+            assert_eq!(import_dir_for_extension(extension), "assets/audio");
+            assert!(IMPORTABLE_ASSET_EXTENSIONS.contains(extension));
+        }
+
+        assert!(asset_from_file_path(Path::new("assets/audio/impact.m4a")).is_none());
+        assert_eq!(import_dir_for_extension("WAV"), "assets/audio");
+    }
+
+    #[test]
+    fn audio_clip_reference_keeps_stable_registry_identity_and_runtime_path() {
+        let asset = EditorAsset {
+            label: "Impact".into(),
+            path: Some("assets/audio/impact.ogg".into()),
+            folder_path: "assets/audio".into(),
+            kind: EditorAssetKind::AudioClip,
+        };
+        let stable_id = AssetId(Uuid::nil());
+        let mut world = World::new();
+        world.insert_resource(AssetRegistry {
+            records: vec![AssetRecord {
+                id: stable_id.clone(),
+                path: asset.path.clone().unwrap(),
+                label: asset.label.clone(),
+                kind_tag: "AudioClip".into(),
+                import_settings: Default::default(),
+                dependencies: Vec::new(),
+            }],
+            index_dirty: false,
+        });
+        world.init_resource::<crate::history::EditorHistory>();
+        world.init_resource::<crate::selection::SelectedEntity>();
+
+        let descriptor = audio_source_desc_for_asset(&mut world, &asset).unwrap();
+        let reference = descriptor.clip.unwrap();
+        assert_eq!(reference.asset_id, stable_id.as_string());
+        assert_eq!(reference.sub_asset_id, AUDIO_CLIP_SUB_ASSET_ID);
+        assert_eq!(reference.label, "Impact");
+        assert_eq!(reference.source_path.as_deref(), asset.path.as_deref());
+        assert_eq!(
+            audio_clip_ref_for_asset(&mut world, &asset)
+                .unwrap()
+                .asset_id,
+            reference.asset_id
+        );
+
+        let entity = spawn_asset_at(&mut world, &asset, Vec3::new(1.0, 2.0, 3.0)).unwrap();
+        assert_eq!(
+            world.get::<ActorKind>(entity),
+            Some(&ActorKind::AudioSource)
+        );
+        let placed = world.get::<shared::AudioSourceDesc>(entity).unwrap();
+        assert_eq!(placed.clip.as_ref(), Some(&reference));
+        assert_eq!(
+            world.get::<Transform>(entity).unwrap().translation,
+            Vec3::new(1.0, 2.0, 3.0)
+        );
+        assert!(world.resource::<crate::history::EditorHistory>().can_undo());
+    }
+}
diff --git a/crates/editor/src/assets/materials.rs b/crates/editor/src/assets/materials.rs
index b5eefa9..fffb3a5 100644
--- a/crates/editor/src/assets/materials.rs
+++ b/crates/editor/src/assets/materials.rs
@@ -5,7 +5,7 @@ use bevy_egui::egui;
 use shared::{LevelObject, MaterialAsset, MaterialDesc};
 
 use crate::assets::{EditorAsset, EditorAssetKind, EditorAssets};
-use crate::history::set_material_with_history;
+use crate::history::set_material_group_with_history;
 use crate::ui::inspector::property_row;
 
 pub fn load_material_asset(catalog_path: &str) -> Result<MaterialAsset, String> {
@@ -23,28 +23,21 @@ pub fn apply_material_asset_to_selection(
     world: &mut World,
     asset: &EditorAsset,
     selected: &bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities,
-) {
-    let Some(path) = asset.path.clone() else {
-        return;
-    };
-    let desc = match material_desc_from_asset(&path) {
-        Ok(desc) => desc,
-        Err(err) => {
-            world.resource_mut::<crate::scene_io::SceneIo>().status = err;
-            return;
-        }
-    };
-    for entity in crate::ui::helpers::selected_level_entities(world, selected) {
-        if world.get::<LevelObject>(entity).is_none() {
-            continue;
-        }
-        if world.get::<MaterialDesc>(entity).is_none() {
-            world.entity_mut(entity).insert(desc.clone());
-        }
-        set_material_with_history(world, entity, desc.clone());
-    }
+) -> Result<(), String> {
+    let path = asset
+        .path
+        .clone()
+        .ok_or_else(|| format!("Material has no source path: {}", asset.label))?;
+    let desc = material_desc_from_asset(&path)?;
+    let changes = crate::ui::helpers::selected_level_entities(world, selected)
+        .into_iter()
+        .filter(|entity| world.get::<LevelObject>(*entity).is_some())
+        .map(|entity| (entity, desc.clone()))
+        .collect::<Vec<_>>();
+    set_material_group_with_history(world, changes);
     world.resource_mut::<crate::scene_io::SceneIo>().status =
         format!("Applied material {}", asset.label);
+    Ok(())
 }
 
 pub fn material_asset_picker_ui(
diff --git a/crates/editor/src/assets/mod.rs b/crates/editor/src/assets/mod.rs
index c1d3d39..cf406bd 100644
--- a/crates/editor/src/assets/mod.rs
+++ b/crates/editor/src/assets/mod.rs
@@ -1,5 +1,6 @@
 //! Asset catalog, database, thumbnails, materials, and prefab overrides.
 
+pub mod animation;
 pub mod asset_db;
 mod catalog;
 mod import;
@@ -11,6 +12,25 @@ pub mod thumbnails;
 
 pub use catalog::*;
 pub use thumbnails::{
-    draw_asset_cell_with, invalidate_on_catalog_refresh, kind_icon, prefetch_folder_thumbnails,
-    AssetThumbnailCache, ThumbnailCacheSnapshot, ThumbnailState, ThumbnailStudio, ThumbnailsPlugin,
+    draw_asset_cell_with, gltf_skinned_primitive_labels, invalidate_on_catalog_refresh, kind_icon,
+    prefetch_folder_thumbnails, AssetThumbnailCache, ThumbnailCacheSnapshot, ThumbnailState,
+    ThumbnailStudio, ThumbnailsPlugin,
 };
+
+/// Refreshes both generated contracts derived from one imported model source.
+pub fn refresh_model_artifacts(
+    record: &mut asset_db::AssetRecord,
+) -> Result<static_mesh::StaticMeshManifest, String> {
+    let static_mesh = static_mesh::refresh_static_mesh_artifact(record);
+    let animation = animation::refresh_animation_artifact(record);
+    match (static_mesh, animation) {
+        (Ok(static_mesh), Ok(_)) => Ok(static_mesh),
+        (Err(static_error), Ok(_)) => Err(format!("static mesh processor failed: {static_error}")),
+        (Ok(_), Err(animation_error)) => {
+            Err(format!("animation processor failed: {animation_error}"))
+        }
+        (Err(static_error), Err(animation_error)) => Err(format!(
+            "static mesh processor failed: {static_error}; animation processor failed: {animation_error}"
+        )),
+    }
+}
diff --git a/crates/editor/src/assets/operators.rs b/crates/editor/src/assets/operators.rs
index fae0062..0ff8253 100644
--- a/crates/editor/src/assets/operators.rs
+++ b/crates/editor/src/assets/operators.rs
@@ -8,7 +8,11 @@ use crate::ui::helpers::{
     apply_material_asset_to_selection, apply_texture_to_selection, selected_level_entities,
 };
 
-use super::{spawn_asset_at, spawn_subasset_at, AssetSelection, EditorAsset};
+use super::{
+    animation_clip_authoring_data, animation_skeleton_signature_for_ref, audio_clip_ref_for_asset,
+    compatible_animation_skeleton_for_model, spawn_asset_at, spawn_subasset_at,
+    validate_prefab_asset, AssetSelection, EditorAsset,
+};
 
 fn selection_availability(world: &World, selected: &SelectedEntities) -> OperatorAvailability {
     if selected_level_entities(world, selected).is_empty() {
@@ -26,6 +30,7 @@ pub fn place_asset_operator(world: &mut World, asset: EditorAsset, translation:
         &label,
         OperatorAvailability::Ready,
         move |world| {
+            validate_prefab_asset(world, &asset)?;
             spawn_asset_at(world, &asset, translation)
                 .map(|_| ())
                 .ok_or_else(|| format!("Asset cannot be placed: {}", asset.label))
@@ -64,10 +69,7 @@ pub fn apply_texture_operator(
         "assets.apply_texture",
         &label,
         availability,
-        move |world| {
-            apply_texture_to_selection(world, &asset, selected);
-            Ok(())
-        },
+        move |world| apply_texture_to_selection(world, &asset, selected),
     )
 }
 
@@ -83,9 +85,414 @@ pub fn apply_material_operator(
         "assets.apply_material",
         &label,
         availability,
+        move |world| apply_material_asset_to_selection(world, &asset, selected),
+    )
+}
+
+pub fn assign_audio_clip_operator(world: &mut World, asset: EditorAsset, entity: Entity) -> bool {
+    let availability = if world.get::<shared::AudioSourceDesc>(entity).is_some() {
+        OperatorAvailability::Ready
+    } else {
+        OperatorAvailability::Disabled("Select an authored audio source".to_string())
+    };
+    let label = format!("Assign Audio Clip {}", asset.label);
+    run_immediate_operator(
+        world,
+        "assets.assign_audio_clip",
+        &label,
+        availability,
         move |world| {
-            apply_material_asset_to_selection(world, &asset, selected);
+            let clip = audio_clip_ref_for_asset(world, &asset)?;
+            let mut source = world
+                .get::<shared::AudioSourceDesc>(entity)
+                .cloned()
+                .ok_or_else(|| "Selected actor is not an audio source".to_string())?;
+            source.clip = Some(clip);
+            crate::history::set_audio_source_with_history(world, entity, source);
             Ok(())
         },
     )
 }
+
+pub fn assign_animation_clip_operator(
+    world: &mut World,
+    selection: AssetSelection,
+    entity: Entity,
+) -> bool {
+    let availability = if world.get::<shared::ModelRef>(entity).is_some() {
+        OperatorAvailability::Ready
+    } else {
+        OperatorAvailability::Disabled("Select an authored imported-model actor".to_string())
+    };
+    let label = format!("Assign Animation Clip {}", selection.display_label());
+    run_immediate_operator(
+        world,
+        "assets.assign_animation_clip",
+        &label,
+        availability,
+        move |world| {
+            let authored = animation_clip_authoring_data(world, &selection)?;
+            let model = world
+                .get::<shared::ModelRef>(entity)
+                .cloned()
+                .ok_or_else(|| "Selected actor has no ModelRef".to_string())?;
+            let mut controller = world
+                .get::<shared::AnimationControllerDesc>(entity)
+                .cloned()
+                .unwrap_or_default();
+
+            let skeleton = match controller.skeleton.as_ref() {
+                Some(reference) => {
+                    let existing_signature =
+                        animation_skeleton_signature_for_ref(world, reference)?;
+                    if existing_signature != authored.skeleton_signature {
+                        return Err(format!(
+                            "Clip `{}` targets rig `{}` but the actor uses `{}`. Animation v1 requires an exact skeleton match.",
+                            authored.state.label,
+                            authored.skeleton_signature.0,
+                            existing_signature.0
+                        ));
+                    }
+                    reference.clone()
+                }
+                None => compatible_animation_skeleton_for_model(
+                    world,
+                    &model,
+                    &authored.skeleton_signature,
+                )?,
+            };
+
+            if controller.states.iter().any(|state| {
+                state.clip.asset_id == authored.state.clip.asset_id
+                    && state.clip.sub_asset_id == authored.state.clip.sub_asset_id
+            }) {
+                return Err(format!(
+                    "Animation controller already contains clip `{}`.",
+                    authored.state.label
+                ));
+            }
+
+            let mut state = authored.state;
+            let base_id = state.id.clone();
+            let mut suffix = 2;
+            while controller.states.iter().any(|entry| entry.id == state.id) {
+                state.id = format!("{base_id}_{suffix}");
+                suffix += 1;
+            }
+            controller.skeleton = Some(skeleton);
+            if controller.default_state.trim().is_empty() {
+                controller.default_state = state.id.clone();
+            }
+            controller.states.push(state);
+            crate::history::set_animation_controller_with_history(world, entity, controller);
+            Ok(())
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use shared::{
+        animation_clip_sub_asset_id, animation_skeleton_sub_asset_id, ActorKind,
+        AnimationClipRecord, AnimationControllerDesc, AnimationManifest, AnimationManifestSource,
+        AnimationSkeletonRecord, AnimationSkeletonSignature, AnimationSourceFingerprint,
+        AudioSourceDesc, LevelObject, MaterialDesc, ModelRef, PrimitiveShape,
+        ANIMATION_MANIFEST_SCHEMA_VERSION,
+    };
+
+    use crate::asset_db::{AssetId, AssetRecord, AssetRegistry, ImportSettings};
+    use crate::history::EditorHistory;
+    use crate::operators::test_harness::{assert_undo_redo_round_trip, OperatorInvariantHarness};
+    use crate::operators::ActiveOperator;
+    use crate::scene_io::SceneIo;
+    use crate::selection::SelectedEntity;
+
+    fn authored_count(world: &mut World) -> usize {
+        let mut query = world.query_filtered::<Entity, With<LevelObject>>();
+        query.iter(world).count()
+    }
+
+    fn animation_fixture() -> (std::path::PathBuf, AssetRecord, AssetSelection) {
+        let model_path = "assets/models/operator_fixture.glb".to_string();
+        let asset_id = AssetId::new();
+        let skeleton_id = animation_skeleton_sub_asset_id(0, "Rig");
+        let clip_id = animation_clip_sub_asset_id(0, "Idle");
+        let manifest = AnimationManifest {
+            schema_version: ANIMATION_MANIFEST_SCHEMA_VERSION,
+            asset_id: asset_id.as_string(),
+            label: "Operator Fixture".into(),
+            source: AnimationManifestSource {
+                path: model_path.clone(),
+                format: "glb".into(),
+                fingerprint: AnimationSourceFingerprint {
+                    byte_len: 1,
+                    modified_unix_secs: 0,
+                    content_hash: "fixture".into(),
+                },
+                dependencies: Vec::new(),
+            },
+            runtime_supported: true,
+            skeletons: vec![AnimationSkeletonRecord {
+                id: skeleton_id,
+                label: "Rig".into(),
+                source_index: 0,
+                signature: AnimationSkeletonSignature::new("exact-rig"),
+                joint_paths: vec!["Root".into()],
+            }],
+            clips: vec![AnimationClipRecord {
+                id: clip_id.clone(),
+                label: "Idle".into(),
+                source_index: 0,
+                duration_seconds: 1.0,
+                target_skeleton_signature: Some(AnimationSkeletonSignature::new("exact-rig")),
+                events: Vec::new(),
+            }],
+            diagnostics: Vec::new(),
+        };
+        let path = std::env::temp_dir().join(format!(
+            "blacksite-animation-operator-{}.animation.ron",
+            uuid::Uuid::new_v4()
+        ));
+        std::fs::write(
+            &path,
+            ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default()).unwrap(),
+        )
+        .unwrap();
+        let record = AssetRecord {
+            id: asset_id,
+            path: model_path.clone(),
+            label: "Operator Fixture".into(),
+            kind_tag: "Model".into(),
+            import_settings: ImportSettings {
+                animation_manifest_path: Some(path.to_string_lossy().into_owned()),
+                ..Default::default()
+            },
+            dependencies: Vec::new(),
+        };
+        let selection = AssetSelection::SubAsset {
+            parent_path: model_path.clone(),
+            sub_asset_id: clip_id,
+            label: "Idle".into(),
+            kind: super::super::AssetSubAssetKind::AnimationClip,
+            source_path: Some(model_path),
+        };
+        (path, record, selection)
+    }
+
+    #[test]
+    fn asset_placement_commits_one_undo_group_and_round_trips() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<SelectedEntity>();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let asset = EditorAsset {
+            label: "Cube".to_string(),
+            path: None,
+            folder_path: "Built-ins".to_string(),
+            kind: super::super::EditorAssetKind::Primitive(PrimitiveShape::Box),
+        };
+
+        assert!(place_asset_operator(&mut world, asset, Vec3::ZERO));
+
+        harness.assert_committed(&mut world, 1, 1);
+        assert_undo_redo_round_trip(&mut world, 0, 1, authored_count);
+    }
+
+    #[test]
+    fn audio_clip_assignment_is_one_undoable_operator() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let path = "assets/audio/impact.ogg".to_string();
+        world.insert_resource(AssetRegistry {
+            records: vec![AssetRecord {
+                id: AssetId::new(),
+                path: path.clone(),
+                label: "Impact".into(),
+                kind_tag: "AudioClip".into(),
+                import_settings: Default::default(),
+                dependencies: Vec::new(),
+            }],
+            index_dirty: false,
+        });
+        let entity = world
+            .spawn((
+                LevelObject,
+                ActorKind::AudioSource,
+                Transform::IDENTITY,
+                AudioSourceDesc::default(),
+            ))
+            .id();
+        let asset = EditorAsset {
+            label: "Impact".into(),
+            path: Some(path.clone()),
+            folder_path: "assets/audio".into(),
+            kind: super::super::EditorAssetKind::AudioClip,
+        };
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let read_clip = move |world: &mut World| {
+            world
+                .get::<AudioSourceDesc>(entity)
+                .and_then(|source| source.clip.clone())
+        };
+
+        assert!(assign_audio_clip_operator(&mut world, asset, entity));
+
+        let assigned = read_clip(&mut world).expect("clip assigned");
+        assert_eq!(assigned.source_path.as_deref(), Some(path.as_str()));
+        harness.assert_committed(&mut world, 1, 0);
+        assert_undo_redo_round_trip(&mut world, None, Some(assigned), read_clip);
+    }
+
+    #[test]
+    fn animation_clip_assignment_is_one_undoable_operator() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let (manifest_path, record, selection) = animation_fixture();
+        let model_path = record.path.clone();
+        world.insert_resource(AssetRegistry {
+            records: vec![record],
+            index_dirty: false,
+        });
+        let entity = world
+            .spawn((
+                LevelObject,
+                ActorKind::ImportedModel,
+                ModelRef::new(model_path),
+            ))
+            .id();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let read_controller =
+            move |world: &mut World| world.get::<AnimationControllerDesc>(entity).cloned();
+
+        assert!(assign_animation_clip_operator(
+            &mut world, selection, entity
+        ));
+
+        let assigned = read_controller(&mut world).expect("controller assigned");
+        assert_eq!(assigned.default_state, "idle");
+        assert_eq!(assigned.states.len(), 1);
+        assert_eq!(assigned.states[0].id, "idle");
+        assert_eq!(
+            assigned.skeleton.as_ref().unwrap().sub_asset_id,
+            animation_skeleton_sub_asset_id(0, "Rig")
+        );
+        harness.assert_committed(&mut world, 1, 0);
+        assert_undo_redo_round_trip(&mut world, None, Some(assigned), read_controller);
+        let _ = std::fs::remove_file(manifest_path);
+    }
+
+    #[test]
+    fn multi_actor_texture_assignment_is_one_undo_group() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let first = world.spawn((LevelObject, MaterialDesc::default())).id();
+        let second = world.spawn((LevelObject, MaterialDesc::default())).id();
+        let mut selected = SelectedEntities::default();
+        selected.select_replace(first);
+        selected.select_maybe_add(second, true);
+        let asset = EditorAsset {
+            label: "Grid".to_string(),
+            path: Some("assets/textures/grid.png".to_string()),
+            folder_path: "assets/textures".to_string(),
+            kind: super::super::EditorAssetKind::Texture,
+        };
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let read_textures = move |world: &mut World| {
+            [first, second]
+                .into_iter()
+                .map(|entity| {
+                    world
+                        .get::<MaterialDesc>(entity)
+                        .and_then(|material| material.base_color_texture.clone())
+                })
+                .collect::<Vec<_>>()
+        };
+
+        assert!(apply_texture_operator(&mut world, asset, &selected));
+
+        harness.assert_committed(&mut world, 1, 0);
+        assert_undo_redo_round_trip(
+            &mut world,
+            vec![None, None],
+            vec![
+                Some("assets/textures/grid.png".to_string()),
+                Some("assets/textures/grid.png".to_string()),
+            ],
+            read_textures,
+        );
+    }
+
+    #[test]
+    fn missing_subasset_commit_cancels_without_side_effects() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let selection = AssetSelection::SubAsset {
+            parent_path: "assets/models/missing.glb".to_string(),
+            sub_asset_id: "mesh:missing".to_string(),
+            label: "Missing Mesh".to_string(),
+            kind: super::super::AssetSubAssetKind::Mesh,
+            source_path: None,
+        };
+
+        assert!(!place_subasset_operator(&mut world, selection, Vec3::ZERO));
+
+        harness.assert_canceled(&mut world);
+    }
+
+    #[test]
+    fn missing_material_source_cancels_without_side_effects() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let entity = world.spawn(LevelObject).id();
+        let mut selected = SelectedEntities::default();
+        selected.select_replace(entity);
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let asset = EditorAsset {
+            label: "Missing Material".to_string(),
+            path: Some("assets/materials/does-not-exist.material.ron".to_string()),
+            folder_path: "assets/materials".to_string(),
+            kind: super::super::EditorAssetKind::Material,
+        };
+
+        assert!(!apply_material_operator(&mut world, asset, &selected));
+
+        harness.assert_canceled(&mut world);
+    }
+
+    #[test]
+    fn texture_assignment_without_authored_selection_is_blocked() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let asset = EditorAsset {
+            label: "Grid".to_string(),
+            path: Some("assets/textures/grid.png".to_string()),
+            folder_path: "assets/textures".to_string(),
+            kind: super::super::EditorAssetKind::Texture,
+        };
+
+        assert!(!apply_texture_operator(
+            &mut world,
+            asset,
+            &SelectedEntities::default()
+        ));
+
+        harness.assert_blocked(&mut world);
+    }
+}
diff --git a/crates/editor/src/assets/prefab_overrides.rs b/crates/editor/src/assets/prefab_overrides.rs
index b37a764..7fe03f0 100644
--- a/crates/editor/src/assets/prefab_overrides.rs
+++ b/crates/editor/src/assets/prefab_overrides.rs
@@ -1,20 +1,32 @@
 //! Prefab instance overrides — apply/revert per field group (v2).
 
-use std::collections::HashMap;
-use std::path::Path;
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
 
 use bevy::prelude::*;
+use bevy::world_serialization::{
+    DynamicWorld, DynamicWorldRoot, WorldInstance, WorldInstanceReady,
+};
 use bevy_egui::egui;
 use egui_phosphor_icons::icons;
-use scene::{migrate_scene_text, strip_schema_version, validate_level_text};
-use serde::{Deserialize, Serialize};
-use shared::{EditorVisibility, MaterialDesc, PrefabInstance};
+use scene::document::{SceneComponentBlob, SceneDocument, SceneEntityId, ScenePatch};
+use shared::{
+    decode_prefab_overrides, encode_prefab_overrides, ActorId, EditorVisibility,
+    HydratedPrefabMember, HydratedPrefabReady, MaterialDesc, PrefabActorPath,
+    PrefabComponentOverride, PrefabInstance, PrefabOverrides, PrefabPropertyOverride, PrefabRef,
+    PrefabStructuralOverride,
+};
 
-use crate::history::{set_material_with_history, set_transform_with_history};
+use crate::asset_db::{ensure_asset_record, AssetRegistry};
+use crate::history::{
+    capture_prefab_edit_state, record_prefab_edit_state, record_prefab_source_apply,
+};
 use crate::ui::inspector::{
     apply_component_card_response, component_card, component_card_context, property_row,
     ComponentCardOptions,
 };
+use crate::ui::theme::{ERROR, SUCCESS, TEXT_MUTED, WARNING};
 
 #[derive(Resource, Default)]
 pub struct PrefabOverrideClipboard {
@@ -22,170 +34,2411 @@ pub struct PrefabOverrideClipboard {
     pub value_ron: String,
 }
 
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
-pub struct PrefabOverrides {
-    #[serde(default)]
-    pub transform: Option<Transform>,
-    #[serde(default)]
-    pub material: Option<MaterialDesc>,
-    #[serde(default)]
-    pub child_visibility: HashMap<String, bool>,
+#[derive(Resource, Default)]
+pub struct PrefabHealthCache {
+    entries: HashMap<Entity, (Instant, PrefabHealth)>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PrefabOverrideField {
-    Transform,
-    Material,
-    ChildVisibility,
+pub fn prefab_source_revision(project_root: &Path, source_path: &str) -> Result<String, String> {
+    scene::prefab_graph_revision(&project_root.join(source_path), project_root)
+}
+
+fn current_source_revision(world: &World, instance: &PrefabInstance) -> Option<String> {
+    let root = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))?;
+    prefab_source_revision(&root, &instance.source_path).ok()
+}
+
+fn track_current_source_revision(
+    world: &World,
+    instance: &PrefabInstance,
+    overrides: &mut PrefabOverrides,
+) {
+    overrides.source_revision = current_source_revision(world, instance);
+}
+
+#[derive(Debug, Clone)]
+enum PrefabHealth {
+    Ready,
+    Loading,
+    Untracked,
+    ChangedBase,
+    Conflict(Vec<String>),
+    Broken(String),
+    InvalidOverrides(String),
+}
+
+fn prefab_health(
+    world: &mut World,
+    entity: Entity,
+    instance: &PrefabInstance,
+    overrides: &PrefabOverrides,
+) -> PrefabHealth {
+    if let Some(health) = world
+        .get_resource::<PrefabHealthCache>()
+        .and_then(|cache| cache.entries.get(&entity))
+        .filter(|(checked, _)| checked.elapsed() < Duration::from_millis(500))
+        .map(|(_, health)| health.clone())
+    {
+        return health;
+    }
+    let health = compute_prefab_health(world, entity, instance, overrides);
+    if let Some(mut cache) = world.get_resource_mut::<PrefabHealthCache>() {
+        cache
+            .entries
+            .insert(entity, (Instant::now(), health.clone()));
+    }
+    health
+}
+
+fn compute_prefab_health(
+    world: &World,
+    entity: Entity,
+    instance: &PrefabInstance,
+    overrides: &PrefabOverrides,
+) -> PrefabHealth {
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return PrefabHealth::Broken("Project workspace is unavailable".to_string());
+    };
+    if let Some(blocked) = world.get::<shared::PrefabHydrationBlocked>(entity) {
+        return PrefabHealth::Broken(blocked.reason.clone());
+    }
+    if let Err(error) =
+        scene::validate_prefab_graph(&project_root.join(&instance.source_path), &project_root)
+    {
+        return PrefabHealth::Broken(error);
+    }
+    if world.get::<HydratedPrefabReady>(entity).is_none() {
+        return PrefabHealth::Loading;
+    }
+    let current = prefab_source_revision(&project_root, &instance.source_path).ok();
+    let known_keys = prefab_legacy_target_keys(&project_root, instance);
+    let mut stale: Vec<String> = overrides
+        .child_visibility
+        .keys()
+        .filter(|key| !known_keys.contains(*key))
+        .cloned()
+        .collect();
+    stale.extend(prefab_semantic_conflicts(
+        &project_root,
+        instance,
+        overrides,
+    ));
+    stale.sort();
+    stale.dedup();
+    if !stale.is_empty() {
+        return PrefabHealth::Conflict(stale);
+    }
+    match (&overrides.source_revision, current) {
+        (None, _) => PrefabHealth::Untracked,
+        (Some(recorded), Some(current)) if recorded != &current => PrefabHealth::ChangedBase,
+        _ => PrefabHealth::Ready,
+    }
+}
+
+fn prefab_legacy_target_keys(project_root: &Path, instance: &PrefabInstance) -> HashSet<String> {
+    let direct = PrefabActorPath::direct("");
+    source_document_for_target(project_root, instance, &direct)
+        .map(|document| {
+            document
+                .entities
+                .into_iter()
+                .flat_map(|entity| [entity.actor_id, entity.name])
+                .flatten()
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn prefab_semantic_conflicts(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    overrides: &PrefabOverrides,
+) -> Vec<String> {
+    let mut conflicts = Vec::new();
+    for property in &overrides.properties {
+        let source = source_component_for_target(
+            project_root,
+            instance,
+            &property.target,
+            &property.component_type,
+        )
+        .and_then(|source| {
+            apply_layer_prerequisites(
+                source,
+                overrides,
+                &property.target,
+                &property.component_type,
+            )
+        });
+        let conflict = match source {
+            Ok(Some(source)) if property.component_type == std::any::type_name::<Transform>() => {
+                apply_transform_property(&source.ron, property).is_err()
+            }
+            Ok(Some(source))
+                if property.component_type == std::any::type_name::<MaterialDesc>() =>
+            {
+                apply_material_property(&source.ron, property).is_err()
+            }
+            Ok(Some(_)) => false,
+            _ => true,
+        };
+        if conflict {
+            conflicts.push(property_conflict_key(property));
+        }
+    }
+    for component in &overrides.components {
+        let current = source_component_for_target(
+            project_root,
+            instance,
+            &component.target,
+            &component.component_type,
+        )
+        .ok()
+        .flatten();
+        let conflict = match (&component.base_component_ron, current) {
+            (None, Some(_)) | (Some(_), None) => true,
+            (Some(base), Some(current)) => {
+                !component_values_equal(&component.component_type, &current.ron, base)
+            }
+            (None, None) => false,
+        };
+        if conflict {
+            conflicts.push(component_conflict_key(component));
+        }
+    }
+    for structural in &overrides.structural {
+        let target = structural_target(structural);
+        let document = source_document_for_target(project_root, instance, target);
+        let source_entity = document.as_ref().ok().and_then(|document| {
+            document.find_entity(&SceneEntityId::ActorId(target.actor_id.clone()))
+        });
+        let conflict = match structural {
+            PrefabStructuralOverride::RemoveChild {
+                base_subtree_revision,
+                ..
+            } => {
+                source_entity.is_none()
+                    || match prefab_source_revision(project_root, &instance.source_path) {
+                        Ok(current) => current != *base_subtree_revision,
+                        Err(_) => true,
+                    }
+            }
+            PrefabStructuralOverride::ReparentChild {
+                base_parent,
+                new_parent,
+                base_transform_ron,
+                ..
+            } => {
+                let parent_changed = match source_parent_for_target(project_root, instance, target)
+                {
+                    Ok(current) => current != *base_parent,
+                    Err(_) => true,
+                };
+                let transform_changed = base_transform_ron.as_ref().is_some_and(|base| {
+                    source_component_for_target(
+                        project_root,
+                        instance,
+                        target,
+                        std::any::type_name::<Transform>(),
+                    )
+                    .ok()
+                    .flatten()
+                    .is_none_or(|current| {
+                        !component_values_equal(
+                            std::any::type_name::<Transform>(),
+                            &current.ron,
+                            base,
+                        )
+                    })
+                });
+                let destination_missing = new_parent.as_ref().is_some_and(|parent| {
+                    parent.instance_chain != target.instance_chain
+                        || source_parent_for_target(project_root, instance, parent).is_err()
+                });
+                parent_changed || transform_changed || destination_missing
+            }
+            PrefabStructuralOverride::AttachLocalChild { .. } => false,
+        };
+        if conflict {
+            conflicts.push(structural_conflict_key(structural));
+        }
+    }
+    conflicts
+}
+
+fn actor_path_key(target: &PrefabActorPath) -> String {
+    if target.instance_chain.is_empty() {
+        target.actor_id.clone()
+    } else {
+        format!("{}/{}", target.instance_chain.join("/"), target.actor_id)
+    }
+}
+
+fn property_conflict_key(property: &PrefabPropertyOverride) -> String {
+    format!(
+        "{}.{}.{}",
+        actor_path_key(&property.target),
+        property.component_type,
+        property.property_path
+    )
+}
+
+fn component_conflict_key(component: &PrefabComponentOverride) -> String {
+    format!(
+        "{}.{}",
+        actor_path_key(&component.target),
+        component.component_type
+    )
+}
+
+fn structural_conflict_key(structural: &PrefabStructuralOverride) -> String {
+    format!(
+        "{}.structure",
+        actor_path_key(structural_target(structural))
+    )
+}
+
+fn source_document_for_target(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    target: &PrefabActorPath,
+) -> Result<SceneDocument, String> {
+    let mut source_path = instance.source_path.clone();
+    for anchor_actor_id in &target.instance_chain {
+        let document = SceneDocument::from_ron_text(
+            &std::fs::read_to_string(project_root.join(&source_path))
+                .map_err(|error| error.to_string())?,
+        )?;
+        let component = document
+            .find_entity(&SceneEntityId::ActorId(anchor_actor_id.clone()))
+            .and_then(|entity| {
+                entity.components.iter().find(|component| {
+                    component.type_name == std::any::type_name::<PrefabInstance>()
+                })
+            })
+            .ok_or_else(|| format!("nested prefab anchor `{anchor_actor_id}` is missing"))?;
+        let nested: PrefabInstance =
+            ron::from_str(&component.ron).map_err(|error| error.to_string())?;
+        source_path = nested.source_path;
+    }
+    SceneDocument::from_ron_text(
+        &std::fs::read_to_string(project_root.join(source_path))
+            .map_err(|error| error.to_string())?,
+    )
+}
+
+fn source_component_for_target(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    target: &PrefabActorPath,
+    component_type: &str,
+) -> Result<Option<SceneComponentBlob>, String> {
+    let mut source_path = instance.source_path.clone();
+    let mut remaining_target = target.clone();
+    let mut layers = Vec::new();
+    for anchor_actor_id in &target.instance_chain {
+        let document = SceneDocument::from_ron_text(
+            &std::fs::read_to_string(project_root.join(&source_path))
+                .map_err(|error| error.to_string())?,
+        )?;
+        let nested_component = document
+            .find_entity(&SceneEntityId::ActorId(anchor_actor_id.clone()))
+            .and_then(|entity| {
+                entity.components.iter().find(|component| {
+                    component.type_name == std::any::type_name::<PrefabInstance>()
+                })
+            })
+            .ok_or_else(|| format!("nested prefab anchor `{anchor_actor_id}` is missing"))?;
+        let nested: PrefabInstance =
+            ron::from_str(&nested_component.ron).map_err(|error| error.to_string())?;
+        remaining_target.instance_chain.remove(0);
+        layers.push((decode_prefab_overrides(&nested)?, remaining_target.clone()));
+        source_path = nested.source_path;
+    }
+    let document = SceneDocument::from_ron_text(
+        &std::fs::read_to_string(project_root.join(source_path))
+            .map_err(|error| error.to_string())?,
+    )?;
+    let mut current = document
+        .find_entity(&SceneEntityId::ActorId(target.actor_id.clone()))
+        .and_then(|entity| {
+            entity
+                .components
+                .iter()
+                .find(|component| component.type_name == component_type)
+        })
+        .cloned();
+    for (overrides, layer_target) in layers.into_iter().rev() {
+        current = apply_layer_to_component(current, &overrides, &layer_target, component_type)?;
+    }
+    Ok(current)
+}
+
+fn source_parent_for_target(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    target: &PrefabActorPath,
+) -> Result<Option<PrefabActorPath>, String> {
+    let mut source_path = instance.source_path.clone();
+    let mut remaining_target = target.clone();
+    let mut layers = Vec::new();
+    for anchor_actor_id in &target.instance_chain {
+        let document = SceneDocument::from_ron_text(
+            &std::fs::read_to_string(project_root.join(&source_path))
+                .map_err(|error| error.to_string())?,
+        )?;
+        let component = document
+            .find_entity(&SceneEntityId::ActorId(anchor_actor_id.clone()))
+            .and_then(|entity| {
+                entity.components.iter().find(|component| {
+                    component.type_name == std::any::type_name::<PrefabInstance>()
+                })
+            })
+            .ok_or_else(|| format!("nested prefab anchor `{anchor_actor_id}` is missing"))?;
+        let nested: PrefabInstance =
+            ron::from_str(&component.ron).map_err(|error| error.to_string())?;
+        remaining_target.instance_chain.remove(0);
+        layers.push((decode_prefab_overrides(&nested)?, remaining_target.clone()));
+        source_path = nested.source_path;
+    }
+    let document = SceneDocument::from_ron_text(
+        &std::fs::read_to_string(project_root.join(source_path))
+            .map_err(|error| error.to_string())?,
+    )?;
+    let mut parent_actor_id = document
+        .find_entity(&SceneEntityId::ActorId(target.actor_id.clone()))
+        .ok_or_else(|| format!("source actor `{}` is missing", actor_path_key(target)))?
+        .parent_actor_id
+        .clone();
+    for (overrides, layer_target) in layers.into_iter().rev() {
+        for structural in &overrides.structural {
+            match structural {
+                PrefabStructuralOverride::RemoveChild { target, .. } if target == &layer_target => {
+                    return Err(format!(
+                        "source actor `{}` was removed by a nested layer",
+                        actor_path_key(target)
+                    ));
+                }
+                PrefabStructuralOverride::ReparentChild {
+                    target,
+                    base_parent,
+                    new_parent,
+                    ..
+                } if target == &layer_target => {
+                    let expected = base_parent.as_ref().map(|parent| parent.actor_id.as_str());
+                    if parent_actor_id.as_deref() != expected {
+                        return Err(format!(
+                            "nested parent override for `{}` conflicts with its source",
+                            actor_path_key(target)
+                        ));
+                    }
+                    parent_actor_id = new_parent.as_ref().map(|parent| parent.actor_id.clone());
+                }
+                _ => {}
+            }
+        }
+    }
+    Ok(parent_actor_id.map(|actor_id| PrefabActorPath {
+        instance_chain: target.instance_chain.clone(),
+        actor_id,
+    }))
+}
+
+fn apply_layer_to_component(
+    current: Option<SceneComponentBlob>,
+    overrides: &PrefabOverrides,
+    target: &PrefabActorPath,
+    component_type: &str,
+) -> Result<Option<SceneComponentBlob>, String> {
+    let mut current = apply_layer_prerequisites(current, overrides, target, component_type)?;
+    for property in &overrides.properties {
+        if property.target != *target || property.component_type != component_type {
+            continue;
+        }
+        let source = current.as_ref().ok_or_else(|| {
+            format!(
+                "nested property `{}` target is missing component `{component_type}`",
+                property.property_path
+            )
+        })?;
+        let ron = if component_type == std::any::type_name::<Transform>() {
+            apply_transform_property(&source.ron, property)?
+        } else if component_type == std::any::type_name::<MaterialDesc>() {
+            apply_material_property(&source.ron, property)?
+        } else {
+            return Err(format!(
+                "nested property resolution does not support component `{component_type}`"
+            ));
+        };
+        current = Some(SceneComponentBlob::from_ron(component_type, ron)?);
+    }
+    if overrides.structural.iter().any(|structural| {
+        matches!(structural, PrefabStructuralOverride::RemoveChild { target: candidate, .. } if candidate == target)
+    }) {
+        return Ok(None);
+    }
+    Ok(current)
+}
+
+fn apply_layer_prerequisites(
+    mut current: Option<SceneComponentBlob>,
+    overrides: &PrefabOverrides,
+    target: &PrefabActorPath,
+    component_type: &str,
+) -> Result<Option<SceneComponentBlob>, String> {
+    if component_type == std::any::type_name::<Transform>() {
+        for structural in &overrides.structural {
+            if let PrefabStructuralOverride::ReparentChild {
+                target: candidate,
+                base_transform_ron,
+                local_transform_ron,
+                ..
+            } = structural
+            {
+                if candidate != target {
+                    continue;
+                }
+                if let Some(base) = base_transform_ron {
+                    let current_ron = current.as_ref().map(|component| component.ron.as_str());
+                    if current_ron
+                        .is_none_or(|value| !component_values_equal(component_type, value, base))
+                    {
+                        return Err(format!(
+                            "nested reparent transform for `{}` conflicts with its source",
+                            actor_path_key(target)
+                        ));
+                    }
+                }
+                if let Some(value) = local_transform_ron {
+                    current = Some(SceneComponentBlob::from_ron(component_type, value.clone())?);
+                }
+            }
+        }
+    }
+    for component in &overrides.components {
+        if component.target != *target || component.component_type != component_type {
+            continue;
+        }
+        let current_ron = current.as_ref().map(|value| value.ron.as_str());
+        let base_matches = match (&component.base_component_ron, current_ron) {
+            (None, None) => true,
+            (Some(base), Some(current)) => component_values_equal(component_type, current, base),
+            _ => false,
+        };
+        if !base_matches {
+            return Err(format!(
+                "nested component `{component_type}` for `{}` conflicts with its source",
+                actor_path_key(target)
+            ));
+        }
+        current = component
+            .value_component_ron
+            .as_ref()
+            .map(|value| SceneComponentBlob::from_ron(component_type, value.clone()))
+            .transpose()?;
+    }
+    Ok(current)
+}
+
+fn source_target_exists(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    target: &PrefabActorPath,
+) -> bool {
+    source_document_for_target(project_root, instance, target)
+        .ok()
+        .and_then(|document| {
+            document
+                .find_entity(&SceneEntityId::ActorId(target.actor_id.clone()))
+                .map(|_| ())
+        })
+        .is_some()
+}
+
+fn accept_current_source(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, entity, &overrides);
+    record_prefab_edit_state(world, entity, old);
+}
+
+fn keep_prefab_overrides(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return;
+    };
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    let prerequisite_layer = overrides.clone();
+    for property in &mut overrides.properties {
+        if let Ok(Some(source)) = source_component_for_target(
+            &project_root,
+            &instance,
+            &property.target,
+            &property.component_type,
+        )
+        .and_then(|source| {
+            apply_layer_prerequisites(
+                source,
+                &prerequisite_layer,
+                &property.target,
+                &property.component_type,
+            )
+        }) {
+            property.base_component_ron = source.ron;
+        }
+    }
+    for component in &mut overrides.components {
+        component.base_component_ron = source_component_for_target(
+            &project_root,
+            &instance,
+            &component.target,
+            &component.component_type,
+        )
+        .ok()
+        .flatten()
+        .map(|source| source.ron);
+    }
+    for structural in &mut overrides.structural {
+        match structural {
+            PrefabStructuralOverride::RemoveChild {
+                base_subtree_revision,
+                ..
+            } => {
+                *base_subtree_revision =
+                    prefab_source_revision(&project_root, &instance.source_path)
+                        .unwrap_or_default();
+            }
+            PrefabStructuralOverride::ReparentChild {
+                target,
+                base_parent,
+                base_transform_ron,
+                ..
+            } => {
+                if let Ok(parent) = source_parent_for_target(&project_root, &instance, target) {
+                    *base_parent = parent;
+                }
+                *base_transform_ron = source_component_for_target(
+                    &project_root,
+                    &instance,
+                    target,
+                    std::any::type_name::<Transform>(),
+                )
+                .ok()
+                .flatten()
+                .map(|component| component.ron);
+            }
+            PrefabStructuralOverride::AttachLocalChild { .. } => {}
+        }
+    }
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, entity, &overrides);
+    record_prefab_edit_state(world, entity, old);
+}
+
+fn take_source_for_conflicts(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return;
+    };
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    let conflicts: HashSet<_> = prefab_semantic_conflicts(&project_root, &instance, &overrides)
+        .into_iter()
+        .collect();
+    overrides
+        .properties
+        .retain(|property| !conflicts.contains(&property_conflict_key(property)));
+    overrides
+        .components
+        .retain(|component| !conflicts.contains(&component_conflict_key(component)));
+    overrides
+        .structural
+        .retain(|structural| !conflicts.contains(&structural_conflict_key(structural)));
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, entity, &overrides);
+    record_prefab_edit_state(world, entity, old);
+}
+
+pub fn revert_prefab_instance_overrides(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let mut overrides = PrefabOverrides::default();
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, entity, &overrides);
+    record_prefab_edit_state(world, entity, old);
+}
+
+fn remove_stale_visibility_overrides(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return;
+    };
+    let known_keys = prefab_legacy_target_keys(&project_root, &instance);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    overrides
+        .child_visibility
+        .retain(|key, _| known_keys.contains(key));
+    overrides
+        .properties
+        .retain(|property| source_target_exists(&project_root, &instance, &property.target));
+    overrides
+        .components
+        .retain(|component| source_target_exists(&project_root, &instance, &component.target));
+    overrides.structural.retain(|structural| match structural {
+        PrefabStructuralOverride::RemoveChild { target, .. }
+        | PrefabStructuralOverride::ReparentChild { target, .. } => {
+            source_target_exists(&project_root, &instance, target)
+        }
+        PrefabStructuralOverride::AttachLocalChild { parent, .. } => {
+            source_target_exists(&project_root, &instance, parent)
+        }
+    });
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, entity, &overrides);
+    record_prefab_edit_state(world, entity, old);
+}
+
+fn discard_invalid_overrides(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(mut instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    instance.overrides_ron = None;
+    world.entity_mut(entity).insert(instance);
+    record_prefab_edit_state(world, entity, old);
+}
+
+fn relink_prefab_source(world: &mut World, entity: Entity) {
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return;
+    };
+    let Some(path) = rfd::FileDialog::new()
+        .set_directory(project_root.join("assets/prefabs"))
+        .add_filter("Bevy prefab", &["scn.ron", "ron"])
+        .pick_file()
+    else {
+        return;
+    };
+    let Ok(path) = path.canonicalize() else {
+        return;
+    };
+    let Ok(root) = project_root.canonicalize() else {
+        return;
+    };
+    let Ok(relative) = path.strip_prefix(&root) else {
+        world.resource_mut::<crate::scene_io::SceneIo>().status =
+            "Prefab source must remain inside the project".into();
+        return;
+    };
+    let source_path = relative.to_string_lossy().replace('\\', "/");
+    if let Err(error) = scene::validate_prefab_graph(&path, &root) {
+        world.resource_mut::<crate::scene_io::SceneIo>().status =
+            format!("Prefab relink failed: {error}");
+        return;
+    }
+    let old = capture_prefab_edit_state(world, entity);
+    let Some(mut instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    instance.source_path = source_path.clone();
+    let label = path
+        .file_stem()
+        .and_then(|value| value.to_str())
+        .unwrap_or("Prefab")
+        .to_string();
+    let registration = world
+        .get_resource_mut::<AssetRegistry>()
+        .ok_or_else(|| "asset registry is unavailable".to_string())
+        .and_then(|mut registry| {
+            ensure_asset_record(&mut registry, source_path.clone(), label, "Prefab")
+        });
+    let record = match registration {
+        Ok(record) => record,
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Prefab relink failed: could not register source: {error}");
+            return;
+        }
+    };
+    instance.asset_id = record.id.as_string();
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    track_current_source_revision(world, &instance, &mut overrides);
+    instance.overrides_ron = encode_prefab_overrides(&overrides).ok().flatten();
+    world
+        .entity_mut(entity)
+        .remove::<shared::PrefabHydrationBlocked>()
+        .insert((instance, PrefabRef::new(source_path)));
+    record_prefab_edit_state(world, entity, old);
+    world.resource_mut::<crate::scene_io::SceneIo>().status = "Prefab source relinked".into();
 }
 
 pub fn read_overrides(instance: &PrefabInstance) -> PrefabOverrides {
+    try_read_overrides(instance).unwrap_or_default()
+}
+
+pub fn try_read_overrides(instance: &PrefabInstance) -> Result<PrefabOverrides, String> {
+    decode_prefab_overrides(instance)
+}
+
+fn read_overrides_for_edit(
+    world: &mut World,
+    instance: &PrefabInstance,
+) -> Option<PrefabOverrides> {
+    match try_read_overrides(instance) {
+        Ok(overrides) => Some(overrides),
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Prefab edit blocked: {error}. Use Discard invalid data to recover.");
+            None
+        }
+    }
+}
+
+pub fn new_tracked_prefab_instance(
+    world: &World,
+    asset_id: impl Into<String>,
+    source_path: impl Into<String>,
+) -> PrefabInstance {
+    let mut instance = PrefabInstance::new(asset_id, source_path);
+    let mut overrides = PrefabOverrides::default();
+    track_current_source_revision(world, &instance, &mut overrides);
+    if overrides != PrefabOverrides::default() {
+        instance.overrides_ron = encode_prefab_overrides(&overrides).ok().flatten();
+    }
     instance
-        .overrides_ron
-        .as_ref()
-        .and_then(|ron| ron::from_str(ron).ok())
-        .unwrap_or_default()
 }
 
 pub fn write_overrides(world: &mut World, entity: Entity, overrides: &PrefabOverrides) {
     let Some(mut instance) = world.get::<PrefabInstance>(entity).cloned() else {
         return;
     };
-    instance.overrides_ron = if overrides == &PrefabOverrides::default() {
-        None
-    } else {
-        Some(ron::to_string(overrides).unwrap_or_default())
-    };
+    instance.overrides_ron = encode_prefab_overrides(overrides).unwrap_or_default();
     if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
         entity_mut.insert(instance);
     }
 }
 
-pub fn has_override(overrides: &PrefabOverrides, field: PrefabOverrideField) -> bool {
-    match field {
-        PrefabOverrideField::Transform => overrides.transform.is_some(),
-        PrefabOverrideField::Material => overrides.material.is_some(),
-        PrefabOverrideField::ChildVisibility => !overrides.child_visibility.is_empty(),
+pub fn set_child_visibility_override(
+    world: &mut World,
+    entity: Entity,
+    child: Entity,
+    visible: bool,
+) {
+    let Some((instance_root, target)) = prefab_member_override_target(world, child) else {
+        world.resource_mut::<crate::scene_io::SceneIo>().status =
+            "Cannot store prefab visibility: target has no stable prefab path".into();
+        return;
+    };
+    if instance_root != entity {
+        return;
     }
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return;
+    };
+    let component_type = std::any::type_name::<EditorVisibility>().to_string();
+    let value = EditorVisibility { visible };
+    let value_component_ron = match ron::to_string(&value) {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    let source_base = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+        .and_then(|project_root| {
+            source_component_for_target(&project_root, &instance, &target, &component_type)
+                .ok()
+                .flatten()
+                .map(|component| component.ron)
+        });
+
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    overrides.child_visibility.remove(&target.actor_id);
+    let base_component_ron = overrides
+        .components
+        .iter()
+        .find(|candidate| candidate.target == target && candidate.component_type == component_type)
+        .and_then(|candidate| candidate.base_component_ron.clone())
+        .or(source_base);
+    overrides.components.retain(|candidate| {
+        !(candidate.target == target && candidate.component_type == component_type)
+    });
+    overrides.components.push(PrefabComponentOverride {
+        target,
+        component_type,
+        base_component_ron,
+        value_component_ron: Some(value_component_ron),
+    });
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    world.entity_mut(child).insert(value);
+    record_prefab_edit_state(world, instance_root, old);
 }
 
-pub fn capture_transform_override(world: &mut World, entity: Entity) {
-    let Some(transform) = world.get::<Transform>(entity).copied() else {
-        return;
-    };
-    let Some(instance) = world.get::<PrefabInstance>(entity) else {
-        return;
-    };
-    let mut overrides = read_overrides(instance);
-    overrides.transform = Some(transform);
-    write_overrides(world, entity, &overrides);
+pub fn prefab_member_override_target(
+    world: &World,
+    member: Entity,
+) -> Option<(Entity, PrefabActorPath)> {
+    let actor_id = world.get::<ActorId>(member)?.0.clone();
+    let mut instance_root = world.get::<HydratedPrefabMember>(member)?.instance_root;
+    let mut instance_chain = Vec::new();
+    let mut seen = HashSet::new();
+    while seen.insert(instance_root) {
+        let Some(owner) = world.get::<HydratedPrefabMember>(instance_root) else {
+            break;
+        };
+        instance_chain.insert(0, world.get::<ActorId>(instance_root)?.0.clone());
+        instance_root = owner.instance_root;
+    }
+    world.get::<PrefabInstance>(instance_root)?;
+    Some((
+        instance_root,
+        PrefabActorPath {
+            instance_chain,
+            actor_id,
+        },
+    ))
 }
 
-pub fn revert_transform_override(world: &mut World, entity: Entity) {
-    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+pub fn set_prefab_material_property_override(
+    world: &mut World,
+    member: Entity,
+    property_path: &str,
+    value: MaterialDesc,
+) {
+    record_prefab_property_override(world, member, property_path, value);
+}
+
+pub fn set_prefab_transform_property_override(
+    world: &mut World,
+    member: Entity,
+    property_path: &str,
+    value: Transform,
+) {
+    record_prefab_property_override(world, member, property_path, value);
+}
+
+fn record_prefab_property_override<T>(
+    world: &mut World,
+    member: Entity,
+    property_path: &str,
+    value: T,
+) where
+    T: Component + Clone + serde::Serialize,
+{
+    let Some((instance_root, target)) = prefab_member_override_target(world, member) else {
         return;
     };
-    let Some(old) = world.get::<Transform>(entity).copied() else {
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
         return;
     };
-    let Some(source_transform) = prefab_root_transform(&instance.source_path) else {
+    let Some(current) = world.get::<T>(member).cloned() else {
+        return;
+    };
+    let component_type = std::any::type_name::<T>().to_string();
+    let current_ron = match ron::to_string(&current) {
+        Ok(value) => value,
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Could not capture prefab property: {error}");
+            return;
+        }
+    };
+    let value_ron = match ron::to_string(&value) {
+        Ok(value) => value,
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Could not encode prefab property: {error}");
+            return;
+        }
+    };
+
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    let base_component_ron = overrides
+        .properties
+        .iter()
+        .find(|candidate| candidate.target == target && candidate.component_type == component_type)
+        .map(|candidate| candidate.base_component_ron.clone())
+        .unwrap_or(current_ron);
+    overrides.properties.retain(|candidate| {
+        !(candidate.target == target
+            && candidate.component_type == component_type
+            && candidate.property_path == property_path)
+    });
+    overrides.properties.push(PrefabPropertyOverride {
+        target,
+        component_type,
+        property_path: property_path.to_string(),
+        base_component_ron,
+        value_component_ron: value_ron,
+    });
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    world.entity_mut(member).insert(value);
+    record_prefab_edit_state(world, instance_root, old);
+}
+
+pub fn remove_prefab_component_override<T>(world: &mut World, member: Entity)
+where
+    T: Component + Clone + serde::Serialize,
+{
+    let Some((instance_root, target)) = prefab_member_override_target(world, member) else {
+        return;
+    };
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return;
+    };
+    let Some(current) = world.get::<T>(member).cloned() else {
+        return;
+    };
+    let Ok(current_component_ron) = ron::to_string(&current) else {
+        return;
+    };
+    let component_type = std::any::type_name::<T>().to_string();
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    let existing_component = overrides
+        .components
+        .iter()
+        .find(|candidate| candidate.target == target && candidate.component_type == component_type);
+    let cancels_local_add = existing_component.is_some_and(|component| {
+        component.base_component_ron.is_none() && component.value_component_ron.is_some()
+    });
+    let base_component_ron = existing_component
+        .and_then(|component| component.base_component_ron.clone())
+        .or_else(|| {
+            overrides
+                .properties
+                .iter()
+                .find(|candidate| {
+                    candidate.target == target && candidate.component_type == component_type
+                })
+                .map(|property| property.base_component_ron.clone())
+        })
+        .or_else(|| {
+            world
+                .get_resource::<crate::project_io::ProjectWorkspace>()
+                .map(|workspace| PathBuf::from(&workspace.root))
+                .and_then(|project_root| {
+                    source_component_for_target(&project_root, &instance, &target, &component_type)
+                        .ok()
+                        .flatten()
+                        .map(|component| component.ron)
+                })
+        })
+        .or(Some(current_component_ron));
+    overrides.properties.retain(|candidate| {
+        !(candidate.target == target && candidate.component_type == component_type)
+    });
+    overrides.components.retain(|candidate| {
+        !(candidate.target == target && candidate.component_type == component_type)
+    });
+    if !cancels_local_add {
+        overrides.components.push(PrefabComponentOverride {
+            target,
+            component_type,
+            base_component_ron,
+            value_component_ron: None,
+        });
+    }
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    world.entity_mut(member).remove::<T>();
+    record_prefab_edit_state(world, instance_root, old);
+}
+
+pub fn set_prefab_component_override<T>(world: &mut World, member: Entity, value: T)
+where
+    T: Component + Clone + serde::Serialize,
+{
+    let Some((instance_root, target)) = prefab_member_override_target(world, member) else {
+        return;
+    };
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return;
+    };
+    let value_component_ron = match ron::to_string(&value) {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    let component_type = std::any::type_name::<T>().to_string();
+    let base_component_ron = world
+        .get::<T>(member)
+        .and_then(|current| ron::to_string(current).ok());
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    let base_component_ron = overrides
+        .components
+        .iter()
+        .find(|candidate| candidate.target == target && candidate.component_type == component_type)
+        .and_then(|candidate| candidate.base_component_ron.clone())
+        .or(base_component_ron);
+    overrides.components.retain(|candidate| {
+        !(candidate.target == target && candidate.component_type == component_type)
+    });
+    overrides.components.push(PrefabComponentOverride {
+        target,
+        component_type,
+        base_component_ron,
+        value_component_ron: Some(value_component_ron),
+    });
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    world.entity_mut(member).insert(value);
+    record_prefab_edit_state(world, instance_root, old);
+}
+
+pub fn revert_prefab_override_scope(
+    world: &mut World,
+    member: Entity,
+    component_type: Option<&str>,
+    property_path: Option<&str>,
+) {
+    let Some((instance_root, target)) = prefab_member_override_target(world, member) else {
+        return;
+    };
+    revert_prefab_target_scope(world, instance_root, &target, component_type, property_path);
+}
+
+fn revert_prefab_target_scope(
+    world: &mut World,
+    instance_root: Entity,
+    target: &PrefabActorPath,
+    component_type: Option<&str>,
+    property_path: Option<&str>,
+) {
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return;
+    };
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    overrides.properties.retain(|candidate| {
+        candidate.target != *target
+            || component_type.is_some_and(|value| candidate.component_type != value)
+            || property_path.is_some_and(|value| candidate.property_path != value)
+    });
+    if property_path.is_none() {
+        overrides.components.retain(|candidate| {
+            candidate.target != *target
+                || component_type.is_some_and(|value| candidate.component_type != value)
+        });
+    }
+    if component_type.is_none() && property_path.is_none() {
+        overrides
+            .structural
+            .retain(|candidate| structural_target(candidate) != target);
+    }
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    record_prefab_edit_state(world, instance_root, old);
+}
+
+pub fn revert_prefab_actor_path(
+    world: &mut World,
+    instance_root: Entity,
+    target: &PrefabActorPath,
+) {
+    revert_prefab_target_scope(world, instance_root, target, None, None);
+}
+
+pub fn apply_prefab_member_scope_to_source(
+    world: &mut World,
+    member: Entity,
+    component_type: Option<&str>,
+    property_path: Option<&str>,
+) {
+    let Some((instance_root, target)) = prefab_member_override_target(world, member) else {
+        return;
+    };
+    apply_prefab_scope_to_source(
+        world,
+        instance_root,
+        Some(&target),
+        component_type,
+        property_path,
+    );
+}
+
+pub fn apply_prefab_instance_overrides_to_source(world: &mut World, instance_root: Entity) {
+    apply_prefab_scope_to_source(world, instance_root, None, None, None);
+}
+
+pub fn apply_prefab_actor_path_to_source(
+    world: &mut World,
+    instance_root: Entity,
+    target: &PrefabActorPath,
+) {
+    apply_prefab_scope_to_source(world, instance_root, Some(target), None, None);
+}
+
+fn apply_prefab_scope_to_source(
+    world: &mut World,
+    instance_root: Entity,
+    target_filter: Option<&PrefabActorPath>,
+    component_type: Option<&str>,
+    property_path: Option<&str>,
+) {
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return;
+    };
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return;
+    };
+    let source_path = project_root.join(&instance.source_path);
+    let before_source = match std::fs::read_to_string(&source_path) {
+        Ok(source) => source,
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Apply to source failed: {error}");
+            return;
+        }
+    };
+    let mut document = match SceneDocument::from_ron_text(&before_source) {
+        Ok(document) => document,
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Apply to source failed: {error}");
+            return;
+        }
+    };
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    if let Err(error) =
+        promote_legacy_visibility_overrides(&project_root, &instance, &mut overrides)
+    {
         world.resource_mut::<crate::scene_io::SceneIo>().status =
-            "Could not read prefab source for revert".into();
+            format!("Apply to source failed: {error}");
         return;
-    };
-    set_transform_with_history(world, entity, old, source_transform);
-    let mut overrides = read_overrides(&instance);
-    overrides.transform = None;
-    write_overrides(world, entity, &overrides);
-}
-
-pub fn apply_material_override(world: &mut World, entity: Entity) {
-    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
-        return;
-    };
-    let Some(material) = world.get::<MaterialDesc>(entity).cloned() else {
-        world.resource_mut::<crate::scene_io::SceneIo>().status =
-            "Prefab instance has no MaterialDesc to capture".into();
-        return;
-    };
-    let mut overrides = read_overrides(&instance);
-    overrides.material = Some(material);
-    write_overrides(world, entity, &overrides);
-    world.resource_mut::<crate::scene_io::SceneIo>().status = "Material override applied".into();
-}
-
-pub fn revert_material_override(world: &mut World, entity: Entity) {
-    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
-        return;
-    };
-    let Some(source_material) = prefab_root_material(&instance.source_path) else {
-        world.resource_mut::<crate::scene_io::SceneIo>().status =
-            "Could not read prefab source material".into();
-        return;
-    };
-    let old = world.get::<MaterialDesc>(entity).cloned();
-    if old.is_some() {
-        set_material_with_history(world, entity, source_material.clone());
+    }
+    let selected_properties: Vec<_> = overrides
+        .properties
+        .iter()
+        .filter(|candidate| {
+            target_filter.is_none_or(|target| candidate.target == *target)
+                && component_type.is_none_or(|value| candidate.component_type == value)
+                && property_path.is_none_or(|value| candidate.property_path == value)
+        })
+        .cloned()
+        .collect();
+    let selected_components: Vec<_> = overrides
+        .components
+        .iter()
+        .filter(|candidate| {
+            target_filter.is_none_or(|target| candidate.target == *target)
+                && component_type.is_none_or(|value| candidate.component_type == value)
+                && (property_path.is_none()
+                    || (candidate.base_component_ron.is_none()
+                        && candidate.value_component_ron.is_some()))
+        })
+        .cloned()
+        .collect();
+    let selected_structural: Vec<_> = if component_type.is_none() && property_path.is_none() {
+        overrides
+            .structural
+            .iter()
+            .filter(|candidate| {
+                target_filter.is_none_or(|target| structural_target(candidate) == target)
+            })
+            .cloned()
+            .collect()
     } else {
-        world.entity_mut(entity).insert(source_material.clone());
+        Vec::new()
+    };
+    if selected_properties.is_empty()
+        && selected_components.is_empty()
+        && selected_structural.is_empty()
+    {
+        world.resource_mut::<crate::scene_io::SceneIo>().status =
+            "No prefab overrides in this scope".into();
+        return;
     }
-    let mut overrides = read_overrides(&instance);
-    overrides.material = None;
-    write_overrides(world, entity, &overrides);
+
+    let apply_result = (|| {
+        for structural in &selected_structural {
+            validate_structural_apply_base(&project_root, &instance, structural)?;
+        }
+        for component in &selected_components {
+            validate_component_apply_base(
+                &project_root,
+                &instance,
+                component,
+                &selected_structural,
+            )?;
+        }
+        for property in &selected_properties {
+            validate_property_apply_base(
+                &project_root,
+                &instance,
+                property,
+                &selected_components,
+                &selected_structural,
+            )?;
+        }
+        for structural in &selected_structural {
+            if matches!(structural, PrefabStructuralOverride::ReparentChild { .. }) {
+                apply_or_transfer_structural(&mut document, structural, &project_root)?;
+            }
+        }
+        for component in &selected_components {
+            if component.target.instance_chain.is_empty() {
+                apply_component_to_document(&mut document, component)?;
+            } else {
+                transfer_component_to_nested_layer(
+                    &mut document,
+                    component.clone(),
+                    &project_root,
+                )?;
+            }
+        }
+        for property in &selected_properties {
+            if property.target.instance_chain.is_empty() {
+                apply_property_to_document(&mut document, property)?;
+            } else {
+                transfer_property_to_nested_layer(&mut document, property.clone(), &project_root)?;
+            }
+        }
+        for structural in &selected_structural {
+            if !matches!(structural, PrefabStructuralOverride::ReparentChild { .. }) {
+                apply_or_transfer_structural(&mut document, structural, &project_root)?;
+            }
+        }
+        let after_source = document.to_ron_text()?;
+        scene::validate_prefab_graph_text(&after_source, &source_path, &project_root)?;
+        crate::scene::recovery::atomic_write(&source_path, after_source.as_bytes())?;
+        Ok::<_, String>(after_source)
+    })();
+    let after_source = match apply_result {
+        Ok(source) => source,
+        Err(error) => {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Apply to source failed: {error}");
+            return;
+        }
+    };
+
+    overrides
+        .properties
+        .retain(|candidate| !selected_properties.contains(candidate));
+    overrides
+        .components
+        .retain(|candidate| !selected_components.contains(candidate));
+    overrides
+        .structural
+        .retain(|candidate| !selected_structural.contains(candidate));
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    record_prefab_source_apply(
+        world,
+        instance_root,
+        source_path,
+        before_source,
+        after_source,
+        old,
+    );
+    world.resource_mut::<crate::scene_io::SceneIo>().status =
+        "Prefab overrides applied to source".into();
 }
 
-pub fn apply_child_visibility_override(world: &mut World, entity: Entity, child: Entity) {
-    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
-        return;
-    };
-    let Some(name) = world.get::<Name>(child).map(|n| n.to_string()) else {
-        return;
-    };
-    let visible = world
-        .get::<EditorVisibility>(child)
-        .map(|v| v.visible)
-        .unwrap_or(true);
+fn apply_or_transfer_structural(
+    document: &mut SceneDocument,
+    structural: &PrefabStructuralOverride,
+    project_root: &Path,
+) -> Result<(), String> {
+    if structural_target(structural).instance_chain.is_empty() {
+        apply_structural_to_document(document, structural)
+    } else {
+        transfer_structural_to_nested_layer(document, structural.clone(), project_root)
+    }
+}
 
-    let mut overrides = read_overrides(&instance);
-    overrides.child_visibility.insert(name, visible);
-    write_overrides(world, entity, &overrides);
+fn validate_property_apply_base(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    property: &PrefabPropertyOverride,
+    selected_components: &[PrefabComponentOverride],
+    selected_structural: &[PrefabStructuralOverride],
+) -> Result<(), String> {
+    let mut current = source_component_for_target(
+        project_root,
+        instance,
+        &property.target,
+        &property.component_type,
+    )?;
+    if property.component_type == std::any::type_name::<Transform>() {
+        if let Some(local_transform_ron) =
+            selected_structural
+                .iter()
+                .find_map(|structural| match structural {
+                    PrefabStructuralOverride::ReparentChild {
+                        target,
+                        local_transform_ron,
+                        ..
+                    } if target == &property.target => local_transform_ron.clone(),
+                    _ => None,
+                })
+        {
+            current = Some(SceneComponentBlob::from_ron(
+                std::any::type_name::<Transform>(),
+                local_transform_ron,
+            )?);
+        }
+    }
+    for component in selected_components.iter().filter(|component| {
+        component.target == property.target && component.component_type == property.component_type
+    }) {
+        let current_ron = current.as_ref().map(|value| value.ron.as_str());
+        let base_matches = match (&component.base_component_ron, current_ron) {
+            (None, None) => true,
+            (Some(base), Some(current)) => {
+                component_values_equal(&component.component_type, current, base)
+            }
+            _ => false,
+        };
+        if !base_matches {
+            return Err(format!(
+                "conflict: source component `{}` changed",
+                component.component_type
+            ));
+        }
+        current = component
+            .value_component_ron
+            .as_ref()
+            .map(|value| {
+                SceneComponentBlob::from_ron(component.component_type.clone(), value.clone())
+            })
+            .transpose()?;
+    }
+    let source = current.ok_or_else(|| {
+        format!(
+            "source actor `{}` is missing component `{}`",
+            actor_path_key(&property.target),
+            property.component_type
+        )
+    })?;
+    if property.component_type == std::any::type_name::<Transform>() {
+        apply_transform_property(&source.ron, property).map(|_| ())
+    } else if property.component_type == std::any::type_name::<MaterialDesc>() {
+        apply_material_property(&source.ron, property).map(|_| ())
+    } else {
+        Err(format!(
+            "property apply does not support component `{}`",
+            property.component_type
+        ))
+    }
+}
+
+fn validate_component_apply_base(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    component: &PrefabComponentOverride,
+    selected_structural: &[PrefabStructuralOverride],
+) -> Result<(), String> {
+    let mut current = source_component_for_target(
+        project_root,
+        instance,
+        &component.target,
+        &component.component_type,
+    )?;
+    if component.component_type == std::any::type_name::<Transform>() {
+        if let Some(local_transform_ron) =
+            selected_structural
+                .iter()
+                .find_map(|structural| match structural {
+                    PrefabStructuralOverride::ReparentChild {
+                        target,
+                        local_transform_ron,
+                        ..
+                    } if target == &component.target => local_transform_ron.clone(),
+                    _ => None,
+                })
+        {
+            current = Some(SceneComponentBlob::from_ron(
+                std::any::type_name::<Transform>(),
+                local_transform_ron,
+            )?);
+        }
+    }
+    let current_ron = current.as_ref().map(|value| value.ron.as_str());
+    let base_matches = match (&component.base_component_ron, current_ron) {
+        (None, None) => true,
+        (Some(base), Some(current)) => {
+            component_values_equal(&component.component_type, current, base)
+        }
+        _ => false,
+    };
+    if base_matches {
+        Ok(())
+    } else {
+        Err(format!(
+            "conflict: source component `{}` changed",
+            component.component_type
+        ))
+    }
+}
+
+fn structural_target(structural: &PrefabStructuralOverride) -> &PrefabActorPath {
+    match structural {
+        PrefabStructuralOverride::RemoveChild { target, .. }
+        | PrefabStructuralOverride::ReparentChild { target, .. } => target,
+        PrefabStructuralOverride::AttachLocalChild { parent, .. } => parent,
+    }
+}
+
+fn promote_legacy_visibility_overrides(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    overrides: &mut PrefabOverrides,
+) -> Result<(), String> {
+    if overrides.child_visibility.is_empty() {
+        return Ok(());
+    }
+    let direct = PrefabActorPath::direct("");
+    let document = source_document_for_target(project_root, instance, &direct)?;
+    let component_type = std::any::type_name::<EditorVisibility>().to_string();
+    let legacy = std::mem::take(&mut overrides.child_visibility);
+    for (key, visible) in legacy {
+        let source = document
+            .entities
+            .iter()
+            .find(|entity| {
+                entity.actor_id.as_deref() == Some(key.as_str())
+                    || entity.name.as_deref() == Some(key.as_str())
+            })
+            .ok_or_else(|| format!("legacy visibility target `{key}` no longer exists"))?;
+        let actor_id = source
+            .actor_id
+            .clone()
+            .ok_or_else(|| format!("legacy visibility target `{key}` has no ActorId"))?;
+        let target = PrefabActorPath::direct(actor_id);
+        let base_component_ron = source
+            .components
+            .iter()
+            .find(|component| component.type_name == component_type)
+            .map(|component| component.ron.clone());
+        overrides.components.retain(|candidate| {
+            !(candidate.target == target && candidate.component_type == component_type)
+        });
+        overrides.components.push(PrefabComponentOverride {
+            target,
+            component_type: component_type.clone(),
+            base_component_ron,
+            value_component_ron: Some(
+                ron::to_string(&EditorVisibility { visible }).map_err(|error| error.to_string())?,
+            ),
+        });
+    }
+    Ok(())
+}
+
+fn apply_property_to_document(
+    document: &mut SceneDocument,
+    property: &PrefabPropertyOverride,
+) -> Result<(), String> {
+    let target = SceneEntityId::ActorId(property.target.actor_id.clone());
+    let source = document
+        .find_entity(&target)
+        .and_then(|entity| {
+            entity
+                .components
+                .iter()
+                .find(|component| component.type_name == property.component_type)
+        })
+        .cloned()
+        .ok_or_else(|| {
+            format!(
+                "source actor `{}` is missing component `{}`",
+                property.target.actor_id, property.component_type
+            )
+        })?;
+    let ron = if property.component_type == std::any::type_name::<Transform>() {
+        apply_transform_property(&source.ron, property)?
+    } else if property.component_type == std::any::type_name::<MaterialDesc>() {
+        apply_material_property(&source.ron, property)?
+    } else {
+        return Err(format!(
+            "property apply does not support component `{}`",
+            property.component_type
+        ));
+    };
+    document.apply_patch(ScenePatch::SetComponent {
+        target,
+        component: SceneComponentBlob::from_ron(property.component_type.clone(), ron)?,
+    })
+}
+
+fn apply_transform_property(
+    source_ron: &str,
+    property: &PrefabPropertyOverride,
+) -> Result<String, String> {
+    let mut source: Transform = ron::from_str(source_ron).map_err(|error| error.to_string())?;
+    let base: Transform =
+        ron::from_str(&property.base_component_ron).map_err(|error| error.to_string())?;
+    let value: Transform =
+        ron::from_str(&property.value_component_ron).map_err(|error| error.to_string())?;
+    let conflict = match property.property_path.as_str() {
+        "translation" => {
+            let conflict = source.translation != base.translation;
+            source.translation = value.translation;
+            conflict
+        }
+        "rotation" => {
+            let conflict = source.rotation != base.rotation;
+            source.rotation = value.rotation;
+            conflict
+        }
+        "scale" => {
+            let conflict = source.scale != base.scale;
+            source.scale = value.scale;
+            conflict
+        }
+        path => return Err(format!("unsupported Transform property `{path}`")),
+    };
+    if conflict {
+        return Err(format!(
+            "conflict: source Transform.{} changed since the override was created",
+            property.property_path
+        ));
+    }
+    ron::to_string(&source).map_err(|error| error.to_string())
+}
+
+fn apply_material_property(
+    source_ron: &str,
+    property: &PrefabPropertyOverride,
+) -> Result<String, String> {
+    let mut source: MaterialDesc = ron::from_str(source_ron).map_err(|error| error.to_string())?;
+    let base: MaterialDesc =
+        ron::from_str(&property.base_component_ron).map_err(|error| error.to_string())?;
+    let value: MaterialDesc =
+        ron::from_str(&property.value_component_ron).map_err(|error| error.to_string())?;
+    let conflict = match property.property_path.as_str() {
+        "base_color" => {
+            let conflict = source.base_color != base.base_color;
+            source.base_color = value.base_color;
+            conflict
+        }
+        "metallic" => {
+            let conflict = source.metallic != base.metallic;
+            source.metallic = value.metallic;
+            conflict
+        }
+        "roughness" => {
+            let conflict = source.roughness != base.roughness;
+            source.roughness = value.roughness;
+            conflict
+        }
+        path => return Err(format!("unsupported MaterialDesc property `{path}`")),
+    };
+    if conflict {
+        return Err(format!(
+            "conflict: source MaterialDesc.{} changed since the override was created",
+            property.property_path
+        ));
+    }
+    ron::to_string(&source).map_err(|error| error.to_string())
+}
+
+fn apply_component_to_document(
+    document: &mut SceneDocument,
+    component: &PrefabComponentOverride,
+) -> Result<(), String> {
+    let target = SceneEntityId::ActorId(component.target.actor_id.clone());
+    let current = document.find_entity(&target).and_then(|entity| {
+        entity
+            .components
+            .iter()
+            .find(|candidate| candidate.type_name == component.component_type)
+    });
+    match (&component.base_component_ron, current) {
+        (None, Some(_)) => {
+            return Err(format!(
+                "conflict: source actor `{}` gained component `{}`",
+                component.target.actor_id, component.component_type
+            ));
+        }
+        (Some(base), Some(current))
+            if !component_values_equal(&component.component_type, &current.ron, base) =>
+        {
+            return Err(format!(
+                "conflict: source component `{}` changed",
+                component.component_type
+            ));
+        }
+        (Some(_), None) => {
+            return Err(format!(
+                "conflict: source component `{}` was removed",
+                component.component_type
+            ));
+        }
+        _ => {}
+    }
+    match &component.value_component_ron {
+        Some(value) => document.apply_patch(ScenePatch::SetComponent {
+            target,
+            component: SceneComponentBlob::from_ron(
+                component.component_type.clone(),
+                value.clone(),
+            )?,
+        }),
+        None => document.apply_patch(ScenePatch::RemoveComponent {
+            target,
+            component_type: component.component_type.clone(),
+        }),
+    }
+}
+
+fn component_values_equal(component_type: &str, left: &str, right: &str) -> bool {
+    if component_type == std::any::type_name::<Transform>() {
+        return ron::from_str::<Transform>(left).ok() == ron::from_str::<Transform>(right).ok();
+    }
+    if component_type == std::any::type_name::<MaterialDesc>() {
+        return ron::from_str::<MaterialDesc>(left).ok()
+            == ron::from_str::<MaterialDesc>(right).ok();
+    }
+    ron::from_str::<ron::Value>(left).ok() == ron::from_str::<ron::Value>(right).ok()
+}
+
+fn apply_structural_to_document(
+    document: &mut SceneDocument,
+    structural: &PrefabStructuralOverride,
+) -> Result<(), String> {
+    match structural {
+        PrefabStructuralOverride::RemoveChild { target, .. } => {
+            document.apply_patch(ScenePatch::DeleteEntity {
+                target: SceneEntityId::ActorId(target.actor_id.clone()),
+            })
+        }
+        PrefabStructuralOverride::ReparentChild {
+            target,
+            new_parent,
+            local_transform_ron,
+            ..
+        } => {
+            if new_parent
+                .as_ref()
+                .is_some_and(|parent| !parent.instance_chain.is_empty())
+            {
+                return Err("cannot apply a cross-layer parent to this source".to_string());
+            }
+            if document_reparent_would_cycle(document, target, new_parent.as_ref()) {
+                return Err(format!(
+                    "reparenting `{}` would create a hierarchy cycle",
+                    actor_path_key(target)
+                ));
+            }
+            document.apply_patch(ScenePatch::Reparent {
+                target: SceneEntityId::ActorId(target.actor_id.clone()),
+                parent_actor_id: new_parent.as_ref().map(|parent| parent.actor_id.clone()),
+            })?;
+            if let Some(transform_ron) = local_transform_ron {
+                document.apply_patch(ScenePatch::SetComponent {
+                    target: SceneEntityId::ActorId(target.actor_id.clone()),
+                    component: SceneComponentBlob::from_ron(
+                        std::any::type_name::<Transform>(),
+                        transform_ron.clone(),
+                    )?,
+                })?;
+            }
+            Ok(())
+        }
+        PrefabStructuralOverride::AttachLocalChild { .. } => {
+            Err("local child attachment must be converted before source apply".to_string())
+        }
+    }
+}
+
+fn document_reparent_would_cycle(
+    document: &SceneDocument,
+    target: &PrefabActorPath,
+    new_parent: Option<&PrefabActorPath>,
+) -> bool {
+    let Some(new_parent) = new_parent else {
+        return false;
+    };
+    let mut current = Some(new_parent.actor_id.as_str());
+    let mut seen = HashSet::new();
+    while let Some(actor_id) = current {
+        if actor_id == target.actor_id || !seen.insert(actor_id.to_string()) {
+            return true;
+        }
+        current = document
+            .find_entity(&SceneEntityId::ActorId(actor_id.to_string()))
+            .and_then(|entity| entity.parent_actor_id.as_deref());
+    }
+    false
+}
+
+fn validate_structural_apply_base(
+    project_root: &Path,
+    instance: &PrefabInstance,
+    structural: &PrefabStructuralOverride,
+) -> Result<(), String> {
+    let target = structural_target(structural);
+    let document = source_document_for_target(project_root, instance, target)?;
+    let _source = document
+        .find_entity(&SceneEntityId::ActorId(target.actor_id.clone()))
+        .ok_or_else(|| {
+            format!(
+                "conflict: source actor `{}` no longer exists",
+                actor_path_key(target)
+            )
+        })?;
+    match structural {
+        PrefabStructuralOverride::RemoveChild {
+            base_subtree_revision,
+            ..
+        } => {
+            let current = prefab_source_revision(project_root, &instance.source_path)?;
+            if current != *base_subtree_revision {
+                return Err(format!(
+                    "conflict: source subtree `{}` changed since removal was authored",
+                    actor_path_key(target)
+                ));
+            }
+        }
+        PrefabStructuralOverride::ReparentChild {
+            base_parent,
+            new_parent,
+            base_transform_ron,
+            ..
+        } => {
+            let current_parent = source_parent_for_target(project_root, instance, target)?;
+            if current_parent != *base_parent {
+                return Err(format!(
+                    "conflict: source parent for `{}` changed",
+                    actor_path_key(target)
+                ));
+            }
+            if let Some(base) = base_transform_ron {
+                let current = source_component_for_target(
+                    project_root,
+                    instance,
+                    target,
+                    std::any::type_name::<Transform>(),
+                )?
+                .ok_or_else(|| {
+                    format!(
+                        "conflict: source transform for `{}` was removed",
+                        actor_path_key(target)
+                    )
+                })?;
+                if !component_values_equal(std::any::type_name::<Transform>(), &current.ron, base) {
+                    return Err(format!(
+                        "conflict: source transform for `{}` changed",
+                        actor_path_key(target)
+                    ));
+                }
+            }
+            if let Some(parent) = new_parent {
+                if parent.instance_chain != target.instance_chain
+                    || source_parent_for_target(project_root, instance, parent).is_err()
+                {
+                    return Err(format!(
+                        "conflict: destination parent `{}` is unavailable",
+                        actor_path_key(parent)
+                    ));
+                }
+            }
+        }
+        PrefabStructuralOverride::AttachLocalChild { .. } => {}
+    }
+    Ok(())
+}
+
+fn transfer_property_to_nested_layer(
+    document: &mut SceneDocument,
+    mut property: PrefabPropertyOverride,
+    project_root: &Path,
+) -> Result<(), String> {
+    let anchor = property.target.instance_chain.remove(0);
+    update_nested_instance(document, &anchor, project_root, move |overrides, _| {
+        merge_property_override(overrides, property);
+    })
+}
+
+fn transfer_component_to_nested_layer(
+    document: &mut SceneDocument,
+    mut component: PrefabComponentOverride,
+    project_root: &Path,
+) -> Result<(), String> {
+    let anchor = component.target.instance_chain.remove(0);
+    update_nested_instance(document, &anchor, project_root, move |overrides, _| {
+        merge_component_override(overrides, component);
+    })
+}
+
+fn transfer_structural_to_nested_layer(
+    document: &mut SceneDocument,
+    mut structural: PrefabStructuralOverride,
+    project_root: &Path,
+) -> Result<(), String> {
+    let anchor = structural_target(&structural)
+        .instance_chain
+        .first()
+        .cloned()
+        .ok_or_else(|| "nested structural override has no instance path".to_string())?;
+    trim_structural_instance_prefix(&mut structural, &anchor)?;
+    update_nested_instance(
+        document,
+        &anchor,
+        project_root,
+        move |overrides, nested_instance| {
+            let base_revision =
+                prefab_source_revision(project_root, &nested_instance.source_path).ok();
+            merge_structural_override(overrides, structural, base_revision);
+        },
+    )
+}
+
+fn merge_property_override(overrides: &mut PrefabOverrides, mut property: PrefabPropertyOverride) {
+    if let Some(existing) = overrides.properties.iter().find(|candidate| {
+        candidate.target == property.target
+            && candidate.component_type == property.component_type
+            && candidate.property_path == property.property_path
+    }) {
+        property.base_component_ron = existing.base_component_ron.clone();
+    }
+    overrides.properties.retain(|candidate| {
+        !(candidate.target == property.target
+            && candidate.component_type == property.component_type
+            && candidate.property_path == property.property_path)
+    });
+    overrides.properties.push(property);
+}
+
+fn merge_component_override(
+    overrides: &mut PrefabOverrides,
+    mut component: PrefabComponentOverride,
+) {
+    if let Some(existing) = overrides.components.iter().find(|candidate| {
+        candidate.target == component.target && candidate.component_type == component.component_type
+    }) {
+        component.base_component_ron = existing.base_component_ron.clone();
+    }
+    overrides.components.retain(|candidate| {
+        !(candidate.target == component.target
+            && candidate.component_type == component.component_type)
+    });
+    overrides.components.push(component);
+}
+
+fn merge_structural_override(
+    overrides: &mut PrefabOverrides,
+    mut structural: PrefabStructuralOverride,
+    base_revision: Option<String>,
+) {
+    let target = structural_target(&structural).clone();
+    let existing = overrides
+        .structural
+        .iter()
+        .find(|candidate| {
+            std::mem::discriminant(*candidate) == std::mem::discriminant(&structural)
+                && structural_target(candidate) == &target
+        })
+        .cloned();
+    match (&mut structural, existing) {
+        (
+            PrefabStructuralOverride::RemoveChild {
+                base_subtree_revision,
+                ..
+            },
+            Some(PrefabStructuralOverride::RemoveChild {
+                base_subtree_revision: existing,
+                ..
+            }),
+        ) => *base_subtree_revision = existing,
+        (
+            PrefabStructuralOverride::ReparentChild {
+                base_parent,
+                base_transform_ron,
+                ..
+            },
+            Some(PrefabStructuralOverride::ReparentChild {
+                base_parent: existing_parent,
+                base_transform_ron: existing_transform,
+                ..
+            }),
+        ) => {
+            *base_parent = existing_parent;
+            *base_transform_ron = existing_transform;
+        }
+        (
+            PrefabStructuralOverride::RemoveChild {
+                base_subtree_revision,
+                ..
+            },
+            None,
+        ) => {
+            if let Some(revision) = base_revision {
+                *base_subtree_revision = revision;
+            }
+        }
+        _ => {}
+    }
+    overrides.structural.retain(|candidate| {
+        std::mem::discriminant(candidate) != std::mem::discriminant(&structural)
+            || structural_target(candidate) != &target
+    });
+    overrides.structural.push(structural);
+}
+
+pub fn fold_nested_overrides_for_unpack(
+    world: &mut World,
+    instance_root: Entity,
+) -> Result<(), String> {
+    let instance = world
+        .get::<PrefabInstance>(instance_root)
+        .cloned()
+        .ok_or_else(|| "prefab instance is missing".to_string())?;
+    let outer = try_read_overrides(&instance)?;
+    let nested_entities: Vec<(Entity, String, PrefabInstance)> = world
+        .query::<(Entity, &HydratedPrefabMember, &ActorId, &PrefabInstance)>()
+        .iter(world)
+        .filter(|(_, owner, _, _)| owner.instance_root == instance_root)
+        .map(|(entity, _, actor_id, nested)| (entity, actor_id.0.clone(), nested.clone()))
+        .collect();
+    let project_root = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root));
+    let mut updates = Vec::new();
+    for (entity, anchor_actor_id, mut nested_instance) in nested_entities {
+        let mut nested_overrides = try_read_overrides(&nested_instance)?;
+        let mut changed = false;
+        for mut property in outer
+            .properties
+            .iter()
+            .filter(|property| property.target.instance_chain.first() == Some(&anchor_actor_id))
+            .cloned()
+        {
+            property.target.instance_chain.remove(0);
+            merge_property_override(&mut nested_overrides, property);
+            changed = true;
+        }
+        for mut component in outer
+            .components
+            .iter()
+            .filter(|component| component.target.instance_chain.first() == Some(&anchor_actor_id))
+            .cloned()
+        {
+            component.target.instance_chain.remove(0);
+            merge_component_override(&mut nested_overrides, component);
+            changed = true;
+        }
+        for mut structural in outer
+            .structural
+            .iter()
+            .filter(|structural| {
+                structural_target(structural).instance_chain.first() == Some(&anchor_actor_id)
+            })
+            .cloned()
+        {
+            trim_structural_instance_prefix(&mut structural, &anchor_actor_id)?;
+            let base_revision = project_root
+                .as_ref()
+                .and_then(|root| prefab_source_revision(root, &nested_instance.source_path).ok());
+            merge_structural_override(&mut nested_overrides, structural, base_revision);
+            changed = true;
+        }
+        if !changed {
+            continue;
+        }
+        if let Some(root) = project_root.as_ref() {
+            nested_overrides.source_revision =
+                prefab_source_revision(root, &nested_instance.source_path).ok();
+        }
+        nested_instance.overrides_ron = encode_prefab_overrides(&nested_overrides)?;
+        updates.push((entity, nested_instance));
+    }
+    for (entity, nested_instance) in updates {
+        world.entity_mut(entity).insert(nested_instance);
+    }
+    Ok(())
+}
+
+fn trim_structural_instance_prefix(
+    structural: &mut PrefabStructuralOverride,
+    prefix: &str,
+) -> Result<(), String> {
+    let trim = |path: &mut PrefabActorPath| -> Result<(), String> {
+        if path.instance_chain.first().map(String::as_str) != Some(prefix) {
+            return Err("structural override crosses an instance layer".to_string());
+        }
+        path.instance_chain.remove(0);
+        Ok(())
+    };
+    match structural {
+        PrefabStructuralOverride::RemoveChild { target, .. } => trim(target),
+        PrefabStructuralOverride::ReparentChild {
+            target,
+            base_parent,
+            new_parent,
+            ..
+        } => {
+            trim(target)?;
+            if let Some(parent) = base_parent {
+                trim(parent)?;
+            }
+            if let Some(parent) = new_parent {
+                trim(parent)?;
+            }
+            Ok(())
+        }
+        PrefabStructuralOverride::AttachLocalChild { parent, .. } => trim(parent),
+    }
+}
+
+fn update_nested_instance(
+    document: &mut SceneDocument,
+    anchor_actor_id: &str,
+    project_root: &Path,
+    update: impl FnOnce(&mut PrefabOverrides, &PrefabInstance),
+) -> Result<(), String> {
+    let target = SceneEntityId::ActorId(anchor_actor_id.to_string());
+    let component = document
+        .find_entity(&target)
+        .and_then(|entity| {
+            entity
+                .components
+                .iter()
+                .find(|component| component.type_name == std::any::type_name::<PrefabInstance>())
+        })
+        .cloned()
+        .ok_or_else(|| format!("nested prefab anchor `{anchor_actor_id}` is missing"))?;
+    let mut instance: PrefabInstance =
+        ron::from_str(&component.ron).map_err(|error| error.to_string())?;
+    let mut overrides = decode_prefab_overrides(&instance)?;
+    update(&mut overrides, &instance);
+    overrides.source_revision = prefab_source_revision(project_root, &instance.source_path).ok();
+    instance.overrides_ron = encode_prefab_overrides(&overrides)?;
+    document.apply_patch(ScenePatch::SetComponent {
+        target,
+        component: SceneComponentBlob::from_ron(
+            std::any::type_name::<PrefabInstance>(),
+            ron::to_string(&instance).map_err(|error| error.to_string())?,
+        )?,
+    })
+}
+
+pub fn remove_prefab_source_child(world: &mut World, member: Entity) -> bool {
+    let Some((instance_root, target)) = prefab_member_override_target(world, member) else {
+        return false;
+    };
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return false;
+    };
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return false;
+    };
+    overrides
+        .properties
+        .retain(|candidate| candidate.target != target);
+    overrides
+        .components
+        .retain(|candidate| candidate.target != target);
+    overrides
+        .structural
+        .retain(|candidate| structural_target(candidate) != &target);
+    let base_subtree_revision = current_source_revision(world, &instance).unwrap_or_default();
+    overrides
+        .structural
+        .push(PrefabStructuralOverride::RemoveChild {
+            target,
+            base_subtree_revision,
+        });
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    if let Ok(entity_mut) = world.get_entity_mut(member) {
+        entity_mut.despawn();
+    }
+    record_prefab_edit_state(world, instance_root, old);
+    true
+}
+
+pub fn reparent_prefab_source_child(
+    world: &mut World,
+    member: Entity,
+    new_parent: Option<Entity>,
+) -> bool {
+    reparent_prefab_source_children(world, &[member], new_parent)
+}
+
+pub fn reparent_prefab_source_children(
+    world: &mut World,
+    members: &[Entity],
+    new_parent: Option<Entity>,
+) -> bool {
+    let Some(first) = members.first().copied() else {
+        return false;
+    };
+    let Some((instance_root, first_target)) = prefab_member_override_target(world, first) else {
+        return false;
+    };
+    let new_parent_target = match new_parent {
+        Some(parent) => {
+            let Some((parent_root, parent_target)) = prefab_member_override_target(world, parent)
+            else {
+                return false;
+            };
+            if parent_root != instance_root
+                || parent_target.instance_chain != first_target.instance_chain
+            {
+                return false;
+            }
+            Some(parent_target)
+        }
+        None => None,
+    };
+    let runtime_parent = new_parent.unwrap_or(instance_root);
+    let mut plans = Vec::with_capacity(members.len());
+    for member in members.iter().copied() {
+        let Some((owner, target)) = prefab_member_override_target(world, member) else {
+            return false;
+        };
+        if owner != instance_root || target.instance_chain != first_target.instance_chain {
+            return false;
+        }
+        if hierarchy_would_cycle(world, member, runtime_parent) {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                "Prefab reparent blocked: hierarchy cycle".into();
+            return false;
+        }
+        let new_transform = world
+            .get::<GlobalTransform>(member)
+            .map(
+                |global| match world.get::<GlobalTransform>(runtime_parent) {
+                    Some(parent_global) => global.reparented_to(parent_global),
+                    None => global.compute_transform(),
+                },
+            )
+            .or_else(|| world.get::<Transform>(member).copied());
+        let local_transform_ron = new_transform
+            .as_ref()
+            .and_then(|transform| ron::to_string(transform).ok());
+        plans.push((member, target, new_transform, local_transform_ron));
+    }
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return false;
+    };
+    let old = capture_prefab_edit_state(world, instance_root);
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return false;
+    };
+    let project_root = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root));
+    for (member, target, _, local_transform_ron) in &plans {
+        let existing_base = overrides
+            .structural
+            .iter()
+            .find_map(|candidate| match candidate {
+                PrefabStructuralOverride::ReparentChild {
+                    target: existing,
+                    base_parent,
+                    base_transform_ron,
+                    ..
+                } if existing == target => Some((base_parent.clone(), base_transform_ron.clone())),
+                _ => None,
+            });
+        let (base_parent, base_transform_ron) = existing_base.unwrap_or_else(|| {
+            let source_parent = project_root
+                .as_ref()
+                .and_then(|root| source_parent_for_target(root, &instance, target).ok());
+            let base_parent = source_parent.unwrap_or_else(|| {
+                world
+                    .get::<ChildOf>(*member)
+                    .map(ChildOf::parent)
+                    .and_then(|parent| prefab_member_override_target(world, parent))
+                    .filter(|(root, path)| {
+                        *root == instance_root && path.instance_chain == target.instance_chain
+                    })
+                    .map(|(_, path)| path)
+            });
+            let base_transform = project_root
+                .as_ref()
+                .and_then(|root| {
+                    source_component_for_target(
+                        root,
+                        &instance,
+                        target,
+                        std::any::type_name::<Transform>(),
+                    )
+                    .ok()
+                    .flatten()
+                    .map(|component| component.ron)
+                })
+                .or_else(|| {
+                    world
+                        .get::<Transform>(*member)
+                        .and_then(|transform| ron::to_string(transform).ok())
+                });
+            (base_parent, base_transform)
+        });
+        overrides.structural.retain(|candidate| {
+            !matches!(candidate, PrefabStructuralOverride::ReparentChild { target: existing, .. } if existing == target)
+        });
+        if new_parent_target != base_parent {
+            overrides
+                .structural
+                .push(PrefabStructuralOverride::ReparentChild {
+                    target: target.clone(),
+                    base_parent,
+                    new_parent: new_parent_target.clone(),
+                    base_transform_ron,
+                    local_transform_ron: local_transform_ron.clone(),
+                });
+        }
+    }
+    track_current_source_revision(world, &instance, &mut overrides);
+    write_overrides(world, instance_root, &overrides);
+    for (member, _, new_transform, _) in plans {
+        if let Ok(mut entity_mut) = world.get_entity_mut(member) {
+            entity_mut.insert(ChildOf(runtime_parent));
+            if let Some(transform) = new_transform {
+                entity_mut.insert(transform);
+            }
+        }
+    }
+    record_prefab_edit_state(world, instance_root, old);
+    true
+}
+
+fn hierarchy_would_cycle(world: &World, entity: Entity, parent: Entity) -> bool {
+    let mut current = Some(parent);
+    let mut seen = HashSet::new();
+    while let Some(candidate) = current {
+        if candidate == entity || !seen.insert(candidate) {
+            return true;
+        }
+        current = world.get::<ChildOf>(candidate).map(ChildOf::parent);
+    }
+    false
 }
 
 pub fn revert_child_visibility_overrides(world: &mut World, entity: Entity) {
+    let old = capture_prefab_edit_state(world, entity);
     let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
         return;
     };
-    for child in prefab_instance_children(world, entity) {
-        if let Ok(mut entity_mut) = world.get_entity_mut(child) {
-            entity_mut.remove::<EditorVisibility>();
+    let Some(mut overrides) = read_overrides_for_edit(world, &instance) else {
+        return;
+    };
+    if let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    {
+        let _ = promote_legacy_visibility_overrides(&project_root, &instance, &mut overrides);
+    }
+    let component_type = std::any::type_name::<EditorVisibility>();
+    let restorations: Vec<_> = overrides
+        .components
+        .iter()
+        .filter(|component| component.component_type == component_type)
+        .map(|component| {
+            (
+                component.target.clone(),
+                component.base_component_ron.clone(),
+            )
+        })
+        .collect();
+    for (target, base) in restorations {
+        let Some(member) = prefab_member_for_target(world, entity, &target) else {
+            continue;
+        };
+        if let Some(value) = base.and_then(|ron| ron::from_str::<EditorVisibility>(&ron).ok()) {
+            world.entity_mut(member).insert(value);
+        } else {
+            world.entity_mut(member).remove::<EditorVisibility>();
         }
     }
-    let mut overrides = read_overrides(&instance);
     overrides.child_visibility.clear();
+    overrides
+        .components
+        .retain(|component| component.component_type != component_type);
+    track_current_source_revision(world, &instance, &mut overrides);
     write_overrides(world, entity, &overrides);
+    record_prefab_edit_state(world, entity, old);
 }
 
 pub fn apply_stored_overrides(world: &mut World, entity: Entity) {
     let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
         return;
     };
-    let overrides = read_overrides(&instance);
-
-    if let Some(transform) = overrides.transform {
-        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
-            entity_mut.insert(transform);
+    let Ok(overrides) = try_read_overrides(&instance) else {
+        return;
+    };
+    for child in prefab_instance_members(world, entity) {
+        let is_direct = prefab_member_override_target(world, child)
+            .is_some_and(|(root, target)| root == entity && target.instance_chain.is_empty());
+        if !is_direct {
+            continue;
         }
-    }
-    if let Some(material) = overrides.material {
-        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
-            entity_mut.insert(material);
-        }
-    }
-    for child in prefab_instance_children(world, entity) {
-        let Some(name) = world.get::<Name>(child).map(|n| n.to_string()) else {
+        let Some(actor_id) = world.get::<ActorId>(child).map(|id| id.0.as_str()) else {
             continue;
         };
-        if let Some(&visible) = overrides.child_visibility.get(&name) {
+        let legacy_name = world.get::<Name>(child).map(|name| name.as_str());
+        if let Some(&visible) = overrides
+            .child_visibility
+            .get(actor_id)
+            .or_else(|| legacy_name.and_then(|name| overrides.child_visibility.get(name)))
+        {
             if let Ok(mut entity_mut) = world.get_entity_mut(child) {
                 entity_mut.insert(EditorVisibility { visible });
             }
@@ -193,21 +2446,486 @@ pub fn apply_stored_overrides(world: &mut World, entity: Entity) {
     }
 }
 
+fn prefab_member_for_target(
+    world: &mut World,
+    instance_root: Entity,
+    target: &PrefabActorPath,
+) -> Option<Entity> {
+    let candidates: Vec<Entity> = world
+        .query_filtered::<Entity, With<HydratedPrefabMember>>()
+        .iter(world)
+        .collect();
+    candidates.into_iter().find(|candidate| {
+        prefab_member_override_target(world, *candidate).is_some_and(|(root, candidate_target)| {
+            root == instance_root && candidate_target == *target
+        })
+    })
+}
+
+pub fn invalidate_prefab_health_on_ready(
+    ready: On<WorldInstanceReady>,
+    mut health_cache: Option<ResMut<PrefabHealthCache>>,
+) {
+    if let Some(cache) = health_cache.as_deref_mut() {
+        cache.entries.remove(&ready.entity);
+    }
+}
+
+pub fn guard_prefab_reimports(
+    mut events: MessageReader<AssetEvent<DynamicWorld>>,
+    mut failures: MessageReader<bevy::asset::AssetLoadFailedEvent<DynamicWorld>>,
+    roots: Query<(Entity, &DynamicWorldRoot, &PrefabInstance)>,
+    workspace: Res<crate::project_io::ProjectWorkspace>,
+    mut commands: Commands,
+) {
+    let mut changed: std::collections::HashSet<_> = events
+        .read()
+        .filter_map(|event| match event {
+            AssetEvent::Modified { id }
+            | AssetEvent::Removed { id }
+            | AssetEvent::LoadedWithDependencies { id } => Some(*id),
+            _ => None,
+        })
+        .collect();
+    let failed: HashMap<_, _> = failures
+        .read()
+        .map(|failure| {
+            (
+                failure.id,
+                format!("could not load {}: {}", failure.path, failure.error),
+            )
+        })
+        .collect();
+    changed.extend(failed.keys().copied());
+    if changed.is_empty() {
+        return;
+    }
+    let project_root = Path::new(&workspace.root);
+    for (entity, dynamic_root, instance) in &roots {
+        if !changed.contains(&dynamic_root.id()) {
+            continue;
+        }
+        if let Some(reason) = failed.get(&dynamic_root.id()) {
+            let reason = reason.clone();
+            commands.queue(move |world: &mut World| {
+                block_prefab_hydration(world, entity, reason);
+            });
+            continue;
+        }
+        match scene::validate_prefab_graph(&project_root.join(&instance.source_path), project_root)
+        {
+            Ok(()) => {
+                commands
+                    .entity(entity)
+                    .remove::<shared::PrefabHydrationBlocked>();
+            }
+            Err(reason) => {
+                commands.queue(move |world: &mut World| {
+                    block_prefab_hydration(world, entity, reason);
+                });
+            }
+        }
+    }
+}
+
+fn block_prefab_hydration(world: &mut World, entity: Entity, reason: String) {
+    let mut entity = entity;
+    let mut seen = HashSet::new();
+    while seen.insert(entity) {
+        let Some(owner) = world
+            .get::<HydratedPrefabMember>(entity)
+            .map(|member| member.instance_root)
+        else {
+            break;
+        };
+        entity = owner;
+    }
+
+    // Nested instances are owned by generated members of their parent instance. Walk that
+    // ownership graph so an invalid reload cannot leave an unregistered nested tree behind.
+    let ownership: Vec<(Entity, Entity)> = world
+        .query::<(Entity, &HydratedPrefabMember)>()
+        .iter(world)
+        .map(|(member, owner)| (member, owner.instance_root))
+        .collect();
+    let mut owned_roots = HashSet::from([entity]);
+    let mut changed = true;
+    while changed {
+        changed = false;
+        for (member, owner) in &ownership {
+            if owned_roots.contains(owner) && owned_roots.insert(*member) {
+                changed = true;
+            }
+        }
+    }
+    owned_roots.remove(&entity);
+    for member in owned_roots {
+        if let Ok(entity_mut) = world.get_entity_mut(member) {
+            entity_mut.despawn();
+        }
+    }
+
+    if let Ok(mut root) = world.get_entity_mut(entity) {
+        // Remove the asset root while WorldInstance is still present so Bevy unregisters the
+        // instance, then remove the stale ID before a repaired source is hydrated.
+        root.insert(shared::PrefabHydrationBlocked { reason })
+            .remove::<HydratedPrefabReady>()
+            .remove::<DynamicWorldRoot>()
+            .remove::<WorldInstance>();
+    }
+    if let Some(mut cache) = world.get_resource_mut::<PrefabHealthCache>() {
+        cache.entries.remove(&entity);
+    }
+}
+
+fn retry_prefab_source(world: &mut World, entity: Entity) {
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let Some(project_root) = world
+        .get_resource::<crate::project_io::ProjectWorkspace>()
+        .map(|workspace| PathBuf::from(&workspace.root))
+    else {
+        return;
+    };
+    if let Err(error) =
+        scene::validate_prefab_graph(&project_root.join(&instance.source_path), &project_root)
+    {
+        world.resource_mut::<crate::scene_io::SceneIo>().status =
+            format!("Prefab retry failed: {error}");
+        return;
+    }
+
+    block_prefab_hydration(world, entity, "restarting prefab hydration".to_string());
+    if let Ok(mut root) = world.get_entity_mut(entity) {
+        root.remove::<shared::PrefabHydrationBlocked>().insert((
+            instance.clone(),
+            PrefabRef::new(instance.source_path.clone()),
+        ));
+    }
+    world.resource_mut::<crate::scene_io::SceneIo>().status =
+        "Prefab source queued for reload".into();
+}
+
+pub fn prefab_member_inspector_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
+    let Some((instance_root, target)) = prefab_member_override_target(world, entity) else {
+        ui.label(egui::RichText::new("Prefab target unavailable").color(ERROR));
+        return;
+    };
+    let Some(instance) = world.get::<PrefabInstance>(instance_root).cloned() else {
+        return;
+    };
+    let overrides = match try_read_overrides(&instance) {
+        Ok(overrides) => overrides,
+        Err(error) => {
+            ui.label(egui::RichText::new(error).color(ERROR));
+            ui.label("Repair the prefab instance from its root inspector before editing members.");
+            return;
+        }
+    };
+    let transform_type = std::any::type_name::<Transform>();
+    let material_type = std::any::type_name::<MaterialDesc>();
+    let property_active = |component_type: &str, property_path: &str| {
+        overrides.properties.iter().any(|candidate| {
+            candidate.target == target
+                && candidate.component_type == component_type
+                && candidate.property_path == property_path
+        })
+    };
+    let component_active = |component_type: &str| {
+        overrides.components.iter().any(|candidate| {
+            candidate.target == target && candidate.component_type == component_type
+        })
+    };
+
+    ui.horizontal_wrapped(|ui| {
+        ui.label(
+            egui::RichText::new("Override layer")
+                .strong()
+                .color(WARNING),
+        );
+        ui.label(
+            egui::RichText::new(format!("{} / {}", instance.source_path, target.actor_id))
+                .color(TEXT_MUTED),
+        );
+    });
+    ui.add_space(4.0);
+
+    if let Some(mut transform) = world.get::<Transform>(entity).copied() {
+        ui.collapsing("Transform", |ui| {
+            let old_translation = transform.translation;
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Position");
+                ui.add(egui::DragValue::new(&mut transform.translation.x).speed(0.1));
+                ui.add(egui::DragValue::new(&mut transform.translation.y).speed(0.1));
+                ui.add(egui::DragValue::new(&mut transform.translation.z).speed(0.1));
+                if property_active(transform_type, "translation")
+                    && ui.small_button("Revert").clicked()
+                {
+                    revert_prefab_override_scope(
+                        world,
+                        entity,
+                        Some(transform_type),
+                        Some("translation"),
+                    );
+                }
+                if property_active(transform_type, "translation")
+                    && ui.small_button("Apply to source").clicked()
+                {
+                    apply_prefab_member_scope_to_source(
+                        world,
+                        entity,
+                        Some(transform_type),
+                        Some("translation"),
+                    );
+                }
+            });
+            if transform.translation != old_translation {
+                set_prefab_transform_property_override(world, entity, "translation", transform);
+            }
+
+            let old_rotation = transform.rotation;
+            let (yaw, pitch, roll) = transform.rotation.to_euler(EulerRot::YXZ);
+            let mut degrees = Vec3::new(pitch.to_degrees(), yaw.to_degrees(), roll.to_degrees());
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Rotation");
+                ui.add(egui::DragValue::new(&mut degrees.x).speed(0.5));
+                ui.add(egui::DragValue::new(&mut degrees.y).speed(0.5));
+                ui.add(egui::DragValue::new(&mut degrees.z).speed(0.5));
+                if property_active(transform_type, "rotation")
+                    && ui.small_button("Revert").clicked()
+                {
+                    revert_prefab_override_scope(
+                        world,
+                        entity,
+                        Some(transform_type),
+                        Some("rotation"),
+                    );
+                }
+                if property_active(transform_type, "rotation")
+                    && ui.small_button("Apply to source").clicked()
+                {
+                    apply_prefab_member_scope_to_source(
+                        world,
+                        entity,
+                        Some(transform_type),
+                        Some("rotation"),
+                    );
+                }
+            });
+            transform.rotation = Quat::from_euler(
+                EulerRot::YXZ,
+                degrees.y.to_radians(),
+                degrees.x.to_radians(),
+                degrees.z.to_radians(),
+            );
+            if transform.rotation != old_rotation {
+                set_prefab_transform_property_override(world, entity, "rotation", transform);
+            }
+
+            let old_scale = transform.scale;
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Scale");
+                ui.add(egui::DragValue::new(&mut transform.scale.x).speed(0.05));
+                ui.add(egui::DragValue::new(&mut transform.scale.y).speed(0.05));
+                ui.add(egui::DragValue::new(&mut transform.scale.z).speed(0.05));
+                if property_active(transform_type, "scale") && ui.small_button("Revert").clicked() {
+                    revert_prefab_override_scope(
+                        world,
+                        entity,
+                        Some(transform_type),
+                        Some("scale"),
+                    );
+                }
+                if property_active(transform_type, "scale")
+                    && ui.small_button("Apply to source").clicked()
+                {
+                    apply_prefab_member_scope_to_source(
+                        world,
+                        entity,
+                        Some(transform_type),
+                        Some("scale"),
+                    );
+                }
+            });
+            if transform.scale != old_scale {
+                set_prefab_transform_property_override(world, entity, "scale", transform);
+            }
+        });
+    }
+
+    ui.collapsing("Material", |ui| {
+        if let Some(mut material) = world.get::<MaterialDesc>(entity).cloned() {
+            let mut color = [
+                material.base_color.r,
+                material.base_color.g,
+                material.base_color.b,
+                material.base_color.a,
+            ];
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Base color");
+                if ui.color_edit_button_rgba_unmultiplied(&mut color).changed() {
+                    material.base_color.r = color[0];
+                    material.base_color.g = color[1];
+                    material.base_color.b = color[2];
+                    material.base_color.a = color[3];
+                    set_prefab_material_property_override(
+                        world,
+                        entity,
+                        "base_color",
+                        material.clone(),
+                    );
+                }
+                if property_active(material_type, "base_color")
+                    && ui.small_button("Revert").clicked()
+                {
+                    revert_prefab_override_scope(
+                        world,
+                        entity,
+                        Some(material_type),
+                        Some("base_color"),
+                    );
+                }
+                if property_active(material_type, "base_color")
+                    && ui.small_button("Apply to source").clicked()
+                {
+                    apply_prefab_member_scope_to_source(
+                        world,
+                        entity,
+                        Some(material_type),
+                        Some("base_color"),
+                    );
+                }
+            });
+
+            let old_metallic = material.metallic;
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Metallic");
+                ui.add(egui::Slider::new(&mut material.metallic, 0.0..=1.0));
+                if property_active(material_type, "metallic") && ui.small_button("Revert").clicked()
+                {
+                    revert_prefab_override_scope(
+                        world,
+                        entity,
+                        Some(material_type),
+                        Some("metallic"),
+                    );
+                }
+                if property_active(material_type, "metallic")
+                    && ui.small_button("Apply to source").clicked()
+                {
+                    apply_prefab_member_scope_to_source(
+                        world,
+                        entity,
+                        Some(material_type),
+                        Some("metallic"),
+                    );
+                }
+            });
+            if material.metallic != old_metallic {
+                set_prefab_material_property_override(world, entity, "metallic", material.clone());
+            }
+
+            let old_roughness = material.roughness;
+            ui.horizontal_wrapped(|ui| {
+                ui.label("Roughness");
+                ui.add(egui::Slider::new(&mut material.roughness, 0.0..=1.0));
+                if property_active(material_type, "roughness")
+                    && ui.small_button("Revert").clicked()
+                {
+                    revert_prefab_override_scope(
+                        world,
+                        entity,
+                        Some(material_type),
+                        Some("roughness"),
+                    );
+                }
+                if property_active(material_type, "roughness")
+                    && ui.small_button("Apply to source").clicked()
+                {
+                    apply_prefab_member_scope_to_source(
+                        world,
+                        entity,
+                        Some(material_type),
+                        Some("roughness"),
+                    );
+                }
+            });
+            if material.roughness != old_roughness {
+                set_prefab_material_property_override(world, entity, "roughness", material);
+            }
+
+            if ui.small_button("Remove component").clicked() {
+                remove_prefab_component_override::<MaterialDesc>(world, entity);
+            }
+            if overrides.properties.iter().any(|candidate| {
+                candidate.target == target && candidate.component_type == material_type
+            }) || component_active(material_type)
+            {
+                ui.horizontal_wrapped(|ui| {
+                    if ui.small_button("Apply component to source").clicked() {
+                        apply_prefab_member_scope_to_source(
+                            world,
+                            entity,
+                            Some(material_type),
+                            None,
+                        );
+                    }
+                    if ui.small_button("Revert component overrides").clicked() {
+                        revert_prefab_override_scope(world, entity, Some(material_type), None);
+                    }
+                });
+            }
+        } else if component_active(material_type) {
+            ui.horizontal_wrapped(|ui| {
+                if ui.button("Apply removal to source").clicked() {
+                    apply_prefab_member_scope_to_source(world, entity, Some(material_type), None);
+                }
+                if ui.button("Restore source component").clicked() {
+                    revert_prefab_override_scope(world, entity, Some(material_type), None);
+                }
+            });
+        } else if ui.button("Add material component").clicked() {
+            set_prefab_component_override(world, entity, MaterialDesc::default());
+        }
+    });
+
+    ui.separator();
+    ui.horizontal_wrapped(|ui| {
+        if ui.button("Apply actor to source").clicked() {
+            apply_prefab_member_scope_to_source(world, entity, None, None);
+        }
+        if ui.button("Revert actor overrides").clicked() {
+            revert_prefab_override_scope(world, entity, None, None);
+        }
+        if ui
+            .add(egui::Button::new("Remove source actor"))
+            .on_hover_text("Creates an undoable structural override")
+            .clicked()
+        {
+            remove_prefab_source_child(world, entity);
+        }
+    });
+}
+
 pub fn prefab_instance_inspector_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
     let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
         return;
     };
-    let overrides = read_overrides(&instance);
+    let parsed_overrides = try_read_overrides(&instance);
+    let overrides_valid = parsed_overrides.is_ok();
+    let overrides = parsed_overrides.clone().unwrap_or_default();
+    let health = parsed_overrides.map_or_else(PrefabHealth::InvalidOverrides, |_| {
+        prefab_health(world, entity, &instance, &overrides)
+    });
 
-    let card = component_card_context(
-        world,
-        entity,
-        ComponentCardOptions::removable(
-            shared::COMPONENT_PREFAB_INSTANCE,
-            "Prefab Instance",
-            icons::PACKAGE,
-        ),
+    let mut options = ComponentCardOptions::fixed(
+        shared::COMPONENT_PREFAB_INSTANCE,
+        "Prefab Instance",
+        icons::PACKAGE,
     );
+    options.resettable = false;
+    let card = component_card_context(world, entity, options);
     let card_response = component_card(ui, &card, |ui| {
         property_row(ui, "Asset ID", |ui| {
             ui.add(egui::Label::new(instance.asset_id.as_str()).truncate());
@@ -215,163 +2933,274 @@ pub fn prefab_instance_inspector_ui(world: &mut World, ui: &mut egui::Ui, entity
         property_row(ui, "Source", |ui| {
             ui.add(egui::Label::new(instance.source_path.as_str()).truncate());
         });
-
-        ui.collapsing("Transform override", |ui| {
-            let active = has_override(&overrides, PrefabOverrideField::Transform);
-            if active {
-                ui.label(egui::RichText::new("Override active").weak());
+        property_row(ui, "Status", |ui| {
+            let (label, color, detail) = match &health {
+                PrefabHealth::Ready => ("Ready", SUCCESS, None),
+                PrefabHealth::Loading => (
+                    "Loading source",
+                    TEXT_MUTED,
+                    Some("Override targets will be available when the prefab finishes loading"),
+                ),
+                PrefabHealth::Untracked => (
+                    "Base not tracked",
+                    WARNING,
+                    Some("Record the current source revision before production use"),
+                ),
+                PrefabHealth::ChangedBase => (
+                    "Base changed",
+                    WARNING,
+                    Some("The source file changed after these overrides were recorded"),
+                ),
+                PrefabHealth::Conflict(stale) => (
+                    "Override conflict",
+                    ERROR,
+                    Some(if stale.len() == 1 {
+                        "One override conflicts with the current source value, hierarchy, or target"
+                    } else {
+                        "Multiple overrides conflict with current source values, hierarchy, or targets"
+                    }),
+                ),
+                PrefabHealth::Broken(error) => ("Broken source", ERROR, Some(error.as_str())),
+                PrefabHealth::InvalidOverrides(error) => {
+                    ("Invalid overrides", ERROR, Some(error.as_str()))
+                }
+            };
+            let response = ui.label(egui::RichText::new(label).strong().color(color));
+            if let Some(detail) = detail {
+                response.on_hover_text(detail);
             }
-            ui.horizontal_wrapped(|ui| {
-                if ui.button("Apply").clicked() {
-                    capture_transform_override(world, entity);
-                    world.resource_mut::<crate::scene_io::SceneIo>().status =
-                        "Transform override saved".into();
-                }
-                if ui
-                    .add_enabled(active, egui::Button::new("Revert"))
-                    .clicked()
-                {
-                    revert_transform_override(world, entity);
-                }
-            });
         });
 
-        ui.collapsing("Material override", |ui| {
-            let active = has_override(&overrides, PrefabOverrideField::Material);
-            if active {
-                ui.label(egui::RichText::new("Override active").weak());
+        ui.horizontal_wrapped(|ui| match &health {
+            PrefabHealth::Ready => {
+                if ui.small_button("Reload source").clicked() {
+                    world.entity_mut(entity).insert((
+                        instance.clone(),
+                        PrefabRef::new(instance.source_path.clone()),
+                    ));
+                }
+                if ui.small_button("Relink...").clicked() {
+                    relink_prefab_source(world, entity);
+                }
             }
-            ui.horizontal_wrapped(|ui| {
-                if ui.button("Apply").clicked() {
-                    apply_material_override(world, entity);
+            PrefabHealth::Untracked | PrefabHealth::ChangedBase => {
+                if ui.small_button("Accept current base").clicked() {
+                    accept_current_source(world, entity);
                 }
-                if ui
-                    .add_enabled(active, egui::Button::new("Revert"))
-                    .clicked()
-                {
-                    revert_material_override(world, entity);
+                if ui.small_button("Relink...").clicked() {
+                    relink_prefab_source(world, entity);
                 }
-            });
+            }
+            PrefabHealth::Conflict(stale) => {
+                ui.label(
+                    egui::RichText::new(format!("{} conflicts", stale.len())).color(TEXT_MUTED),
+                );
+                if ui.small_button("Keep overrides").clicked() {
+                    keep_prefab_overrides(world, entity);
+                }
+                if ui.small_button("Take source").clicked() {
+                    take_source_for_conflicts(world, entity);
+                }
+                if ui.small_button("Remove missing targets").clicked() {
+                    remove_stale_visibility_overrides(world, entity);
+                }
+                if ui.small_button("Relink...").clicked() {
+                    relink_prefab_source(world, entity);
+                }
+            }
+            PrefabHealth::Broken(_) => {
+                if ui.small_button("Retry source").clicked() {
+                    retry_prefab_source(world, entity);
+                }
+                if ui.small_button("Relink source...").clicked() {
+                    relink_prefab_source(world, entity);
+                }
+            }
+            PrefabHealth::Loading => {
+                ui.spinner();
+            }
+            PrefabHealth::InvalidOverrides(_) => {
+                if ui.small_button("Discard invalid data").clicked() {
+                    discard_invalid_overrides(world, entity);
+                }
+            }
         });
 
-        ui.collapsing("Child visibility overrides", |ui| {
-            let active = has_override(&overrides, PrefabOverrideField::ChildVisibility);
-            if active {
-                ui.label(egui::RichText::new("Overrides stored by child name").weak());
-            }
-            for child in prefab_instance_children(world, entity) {
-                let name = world
-                    .get::<Name>(child)
-                    .map(|n| n.to_string())
-                    .unwrap_or_else(|| format!("{child:?}"));
-                ui.horizontal_wrapped(|ui| {
-                    ui.add(egui::Label::new(name).truncate());
-                    if ui.small_button("Apply").clicked() {
-                        apply_child_visibility_override(world, entity, child);
+        ui.add_enabled_ui(overrides_valid, |ui| {
+            let operation_count = overrides.properties.len()
+                + overrides.components.len()
+                + overrides.structural.len()
+                + overrides.child_visibility.len();
+            ui.horizontal_wrapped(|ui| {
+                ui.label(
+                    egui::RichText::new(format!("{operation_count} override operations"))
+                        .color(TEXT_MUTED),
+                );
+                if ui
+                    .add_enabled(
+                        operation_count > 0,
+                        egui::Button::new("Apply all to source"),
+                    )
+                    .clicked()
+                {
+                    apply_prefab_instance_overrides_to_source(world, entity);
+                }
+                if ui
+                    .add_enabled(operation_count > 0, egui::Button::new("Revert all"))
+                    .clicked()
+                {
+                    revert_prefab_instance_overrides(world, entity);
+                }
+            });
+            if !overrides.structural.is_empty() {
+                let mut structural_action = None;
+                ui.collapsing("Structural overrides", |ui| {
+                    for structural in &overrides.structural {
+                        let target = structural_target(structural).clone();
+                        let operation = match structural {
+                            PrefabStructuralOverride::RemoveChild { .. } => "Removed",
+                            PrefabStructuralOverride::ReparentChild { .. } => "Reparented",
+                            PrefabStructuralOverride::AttachLocalChild { .. } => "Attached",
+                        };
+                        ui.horizontal_wrapped(|ui| {
+                            ui.label(
+                                egui::RichText::new(format!(
+                                    "{operation} {}",
+                                    actor_path_key(&target)
+                                ))
+                                .color(TEXT_MUTED),
+                            );
+                            if ui.small_button("Apply actor").clicked() {
+                                structural_action = Some((true, target.clone()));
+                            }
+                            if ui.small_button("Revert actor").clicked() {
+                                structural_action = Some((false, target));
+                            }
+                        });
                     }
                 });
-            }
-            ui.horizontal_wrapped(|ui| {
-                if ui
-                    .add_enabled(active, egui::Button::new("Revert all"))
-                    .clicked()
-                {
-                    revert_child_visibility_overrides(world, entity);
+                if let Some((apply, target)) = structural_action {
+                    if apply {
+                        apply_prefab_actor_path_to_source(world, entity, &target);
+                    } else {
+                        revert_prefab_actor_path(world, entity, &target);
+                    }
                 }
+            }
+            ui.collapsing("Visibility overrides", |ui| {
+                let visibility_type = std::any::type_name::<EditorVisibility>();
+                let active = !overrides.child_visibility.is_empty()
+                    || overrides
+                        .components
+                        .iter()
+                        .any(|component| component.component_type == visibility_type);
+                if active {
+                    ui.label(egui::RichText::new("Overrides use stable nested actor paths").weak());
+                }
+                for child in prefab_instance_members(world, entity) {
+                    let Some((_, target)) = prefab_member_override_target(world, child) else {
+                        continue;
+                    };
+                    let name = world
+                        .get::<Name>(child)
+                        .map(|n| n.to_string())
+                        .unwrap_or_else(|| format!("{child:?}"));
+                    let mut visible = overrides
+                        .components
+                        .iter()
+                        .find(|component| {
+                            component.target == target
+                                && component.component_type == visibility_type
+                        })
+                        .and_then(|component| component.value_component_ron.as_deref())
+                        .and_then(|ron| ron::from_str::<EditorVisibility>(ron).ok())
+                        .map(|visibility| visibility.visible)
+                        .or_else(|| {
+                            target
+                                .instance_chain
+                                .is_empty()
+                                .then(|| overrides.child_visibility.get(&target.actor_id).copied())
+                                .flatten()
+                        })
+                        .unwrap_or_else(|| {
+                            world
+                                .get::<EditorVisibility>(child)
+                                .map(|visibility| visibility.visible)
+                                .unwrap_or(true)
+                        });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.add(
+                            egui::Label::new(format!("{name} ({})", actor_path_key(&target)))
+                                .truncate(),
+                        );
+                        if ui.checkbox(&mut visible, "Visible").changed() {
+                            set_child_visibility_override(world, entity, child, visible);
+                        }
+                    });
+                }
+                ui.horizontal_wrapped(|ui| {
+                    if ui
+                        .add_enabled(active, egui::Button::new("Revert all"))
+                        .clicked()
+                    {
+                        revert_child_visibility_overrides(world, entity);
+                    }
+                });
             });
         });
 
         ui.horizontal_wrapped(|ui| {
-            if ui.button("Unpack Instance").clicked() {
+            if ui.button("Create Variant...").clicked() {
+                world.resource_mut::<crate::scene_io::SceneIo>().request =
+                    Some(crate::scene_io::SceneIoRequest::SaveSelectionAsPrefab);
+            }
+            if ui
+                .add_enabled(
+                    world.get::<HydratedPrefabReady>(entity).is_some(),
+                    egui::Button::new("Unpack Layer"),
+                )
+                .on_disabled_hover_text("Prefab source has not finished loading")
+                .on_hover_text("Make this prefab layer local while preserving nested prefab links")
+                .clicked()
+            {
                 crate::history::unpack_prefab_instance(world, entity);
             }
+            if ui
+                .add_enabled(
+                    world.get::<HydratedPrefabReady>(entity).is_some(),
+                    egui::Button::new("Convert to Local"),
+                )
+                .on_disabled_hover_text("Prefab source has not finished loading")
+                .on_hover_text(
+                    "Recursively replace this instance and all nested links with local actors",
+                )
+                .clicked()
+            {
+                crate::history::convert_prefab_completely_to_local(world, entity);
+            }
         });
     });
     apply_component_card_response(world, entity, card_response);
 }
 
-fn prefab_instance_children(world: &World, root: Entity) -> Vec<Entity> {
-    let mut children = Vec::new();
-    let mut stack = Vec::new();
-    if let Some(kids) = world.get::<Children>(root) {
-        stack.extend(kids.iter());
-    }
-    while let Some(entity) = stack.pop() {
-        children.push(entity);
-        if let Some(kids) = world.get::<Children>(entity) {
-            stack.extend(kids.iter());
-        }
-    }
-    children
-}
-
-fn prefab_root_transform(source_path: &str) -> Option<Transform> {
-    parse_prefab_root_component::<Transform>(source_path, "Transform")
-}
-
-fn prefab_root_material(source_path: &str) -> Option<MaterialDesc> {
-    parse_prefab_root_component::<MaterialDesc>(source_path, "MaterialDesc")
-}
-
-fn parse_prefab_root_component<T: serde::de::DeserializeOwned>(
-    source_path: &str,
-    type_name: &str,
-) -> Option<T> {
-    let path = Path::new(source_path);
-    let text = std::fs::read_to_string(path).ok()?;
-    validate_level_text(&text).ok()?;
-    let body = strip_schema_version(&migrate_scene_text(&text).ok()?).ok()?;
-    let root_tuple = body.trim().trim_start_matches('(').trim_end_matches(')');
-    for segment in split_top_level_fields(root_tuple) {
-        let segment = segment.trim();
-        if segment.starts_with("entities:") {
-            let entities_body = segment.trim_start_matches("entities:").trim();
-            return parse_first_entity_component(entities_body, type_name);
-        }
-    }
-    None
-}
-
-fn split_top_level_fields(input: &str) -> Vec<String> {
-    let mut fields = Vec::new();
-    let mut depth: i32 = 0;
-    let mut start = 0;
-    for (index, ch) in input.char_indices() {
-        match ch {
-            '(' | '{' => depth += 1,
-            ')' | '}' => depth = depth.saturating_sub(1),
-            ',' if depth == 0 => {
-                fields.push(input[start..index].to_string());
-                start = index + 1;
-            }
-            _ => {}
-        }
-    }
-    if start < input.len() {
-        fields.push(input[start..].to_string());
-    }
-    fields
-}
-
-fn parse_first_entity_component<T: serde::de::DeserializeOwned>(
-    entities_body: &str,
-    type_name: &str,
-) -> Option<T> {
-    let trimmed = entities_body.trim();
-    let inner = trimmed.strip_prefix('{')?.strip_suffix('}')?.trim();
-    let first_entity = inner.split(',').next()?.trim();
-    let components = first_entity
-        .split(':')
-        .nth(1)?
-        .trim()
-        .strip_prefix('(')?
-        .strip_suffix(')')?;
-    for component in split_top_level_fields(components) {
-        if component.contains(type_name) {
-            return ron::from_str::<T>(&format!("({component})")).ok();
-        }
-    }
-    None
+fn prefab_instance_members(world: &mut World, root: Entity) -> Vec<Entity> {
+    let candidates: Vec<Entity> = world
+        .query_filtered::<Entity, With<HydratedPrefabMember>>()
+        .iter(world)
+        .collect();
+    let mut members: Vec<_> = candidates
+        .into_iter()
+        .filter_map(|candidate| {
+            prefab_member_override_target(world, candidate)
+                .filter(|(owner, _)| *owner == root)
+                .map(|(_, target)| (actor_path_key(&target), candidate))
+        })
+        .collect();
+    members.sort_by(|(left, _), (right, _)| left.cmp(right));
+    members
+        .into_iter()
+        .map(|(_, candidate)| candidate)
+        .collect()
 }
 
 pub fn list_prefab_dependencies(path: &str) -> Vec<String> {
@@ -381,10 +3210,1125 @@ pub fn list_prefab_dependencies(path: &str) -> Vec<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use bevy::asset::AssetPlugin;
+    use bevy::prelude::DynamicWorldRoot;
+    use bevy::world_serialization::{DynamicWorld, WorldInstanceSpawner, WorldSerializationPlugin};
+    use shared::LevelObject;
+
+    fn prefab_source(actor_id: &str, material: Option<&MaterialDesc>) -> String {
+        let material = material.map(|material| {
+            format!(
+                ",\"{}\":{}",
+                std::any::type_name::<MaterialDesc>(),
+                ron::to_string(material).unwrap()
+            )
+        });
+        format!(
+            "(schema_version:2,resources:{{}},entities:{{1:(components:{{\"shared::components::LevelObject\":(),\"shared::components::ActorId\":(\"{actor_id}\"),\"shared::components::ActorKind\":Empty,\"{}\":{}{} }})}})",
+            std::any::type_name::<Transform>(),
+            ron::to_string(&Transform::default()).unwrap(),
+            material.unwrap_or_default(),
+        )
+    }
+
+    fn hierarchy_prefab_source(child_transform: Transform) -> String {
+        format!(
+            "(schema_version:2,resources:{{}},entities:{{1:(components:{{\"shared::components::LevelObject\":(),\"shared::components::ActorId\":(\"parent\"),\"shared::components::ActorKind\":Empty,\"{}\":{}}}),2:(components:{{\"shared::components::LevelObject\":(),\"shared::components::ActorId\":(\"child\"),\"shared::components::ActorKind\":Empty,\"{}\":{},\"bevy_ecs::hierarchy::ChildOf\":(1)}})}})",
+            std::any::type_name::<Transform>(),
+            ron::to_string(&Transform::default()).unwrap(),
+            std::any::type_name::<Transform>(),
+            ron::to_string(&child_transform).unwrap(),
+        )
+    }
+
+    fn prefab_test_world(project_root: &Path) -> World {
+        let mut world = World::new();
+        world.init_resource::<crate::scene_io::SceneIo>();
+        world.init_resource::<crate::history::EditorHistory>();
+        world.insert_resource(crate::project_io::ProjectWorkspace {
+            root: project_root.display().to_string(),
+            ..Default::default()
+        });
+        world
+    }
 
     #[test]
     fn empty_overrides_roundtrip() {
         let instance = PrefabInstance::new("id", "assets/prefabs/test.scn.ron");
         assert_eq!(read_overrides(&instance), PrefabOverrides::default());
     }
+
+    #[test]
+    fn nested_unpack_fold_is_transactional_when_a_later_link_is_invalid() {
+        let mut world = World::new();
+        world.init_resource::<crate::scene_io::SceneIo>();
+        let material = MaterialDesc::default();
+        let mut outer = PrefabInstance::new("outer", "assets/prefabs/outer.scn.ron");
+        outer.overrides_ron = encode_prefab_overrides(&PrefabOverrides {
+            properties: ["first", "second"]
+                .into_iter()
+                .map(|anchor| PrefabPropertyOverride {
+                    target: PrefabActorPath {
+                        instance_chain: vec![anchor.to_string()],
+                        actor_id: "mesh".to_string(),
+                    },
+                    component_type: std::any::type_name::<MaterialDesc>().to_string(),
+                    property_path: "roughness".to_string(),
+                    base_component_ron: ron::to_string(&material).unwrap(),
+                    value_component_ron: ron::to_string(&material).unwrap(),
+                })
+                .collect(),
+            ..default()
+        })
+        .unwrap();
+        let root = world.spawn(outer).id();
+        let first = world
+            .spawn((
+                ActorId::new("first"),
+                PrefabInstance::new("first", "assets/prefabs/first.scn.ron"),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        let mut invalid = PrefabInstance::new("second", "assets/prefabs/second.scn.ron");
+        invalid.overrides_ron = Some("invalid".to_string());
+        world.spawn((
+            ActorId::new("second"),
+            invalid,
+            HydratedPrefabMember {
+                instance_root: root,
+            },
+        ));
+
+        assert!(fold_nested_overrides_for_unpack(&mut world, root).is_err());
+        assert!(world
+            .get::<PrefabInstance>(first)
+            .unwrap()
+            .overrides_ron
+            .is_none());
+    }
+
+    #[test]
+    fn property_apply_to_source_is_transactional_and_history_guarded() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-source-apply-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let source_path = prefabs.join("base.scn.ron");
+        let base_material = MaterialDesc::default();
+        let before_source = prefab_source("mesh", Some(&base_material));
+        std::fs::write(&source_path, &before_source).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let instance_root = world
+            .spawn(PrefabInstance::new("base", "assets/prefabs/base.scn.ron"))
+            .id();
+        let member = world
+            .spawn((
+                ActorId::new("mesh"),
+                base_material.clone(),
+                HydratedPrefabMember { instance_root },
+                ChildOf(instance_root),
+            ))
+            .id();
+        let mut overridden = base_material.clone();
+        overridden.roughness = 0.2;
+        set_prefab_material_property_override(&mut world, member, "roughness", overridden);
+
+        apply_prefab_member_scope_to_source(
+            &mut world,
+            member,
+            Some(std::any::type_name::<MaterialDesc>()),
+            Some("roughness"),
+        );
+
+        let applied_source = std::fs::read_to_string(&source_path).unwrap();
+        let document = SceneDocument::from_ron_text(&applied_source).unwrap();
+        let material: MaterialDesc = ron::from_str(
+            &document.entities[0]
+                .components
+                .iter()
+                .find(|component| component.type_name == std::any::type_name::<MaterialDesc>())
+                .unwrap()
+                .ron,
+        )
+        .unwrap();
+        assert_eq!(material.roughness, 0.2);
+        assert!(
+            read_overrides(world.get::<PrefabInstance>(instance_root).unwrap())
+                .properties
+                .is_empty()
+        );
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            2
+        );
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            before_source
+        );
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(instance_root).unwrap())
+                .properties
+                .len(),
+            1
+        );
+        crate::history::apply_command_redo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            applied_source
+        );
+
+        std::fs::write(&source_path, format!("{applied_source}\n")).unwrap();
+        let undo_depth = world
+            .resource::<crate::history::EditorHistory>()
+            .undo_depth();
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            undo_depth
+        );
+        assert!(world
+            .resource::<crate::history::EditorHistory>()
+            .status
+            .contains("changed outside"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn added_component_field_apply_commits_prerequisite_and_round_trips() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-component-apply-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let source_path = prefabs.join("base.scn.ron");
+        let before_source = prefab_source("mesh", None);
+        std::fs::write(&source_path, &before_source).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let instance_root = world
+            .spawn(PrefabInstance::new("base", "assets/prefabs/base.scn.ron"))
+            .id();
+        let member = world
+            .spawn((
+                ActorId::new("mesh"),
+                HydratedPrefabMember { instance_root },
+                ChildOf(instance_root),
+            ))
+            .id();
+        let base = MaterialDesc::default();
+        set_prefab_component_override(&mut world, member, base.clone());
+        let mut edited = base;
+        edited.roughness = 0.17;
+        set_prefab_material_property_override(&mut world, member, "roughness", edited);
+
+        apply_prefab_member_scope_to_source(
+            &mut world,
+            member,
+            Some(std::any::type_name::<MaterialDesc>()),
+            Some("roughness"),
+        );
+
+        let after_source = std::fs::read_to_string(&source_path).unwrap();
+        let document = SceneDocument::from_ron_text(&after_source).unwrap();
+        let material: MaterialDesc = ron::from_str(
+            &document
+                .find_entity(&SceneEntityId::ActorId("mesh".into()))
+                .unwrap()
+                .components
+                .iter()
+                .find(|component| component.type_name == std::any::type_name::<MaterialDesc>())
+                .unwrap()
+                .ron,
+        )
+        .unwrap();
+        assert_eq!(material.roughness, 0.17);
+        let applied = read_overrides(world.get::<PrefabInstance>(instance_root).unwrap());
+        assert!(applied.components.is_empty());
+        assert!(applied.properties.is_empty());
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            before_source
+        );
+        let restored = read_overrides(world.get::<PrefabInstance>(instance_root).unwrap());
+        assert_eq!(restored.components.len(), 1);
+        assert_eq!(restored.properties.len(), 1);
+
+        crate::history::apply_command_redo(&mut world);
+        assert_eq!(std::fs::read_to_string(&source_path).unwrap(), after_source);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn removed_component_apply_and_undo_preserve_source_bytes() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-component-remove-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let source_path = prefabs.join("base.scn.ron");
+        let material = MaterialDesc::default();
+        let before_source = prefab_source("mesh", Some(&material));
+        std::fs::write(&source_path, &before_source).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let instance_root = world
+            .spawn(PrefabInstance::new("base", "assets/prefabs/base.scn.ron"))
+            .id();
+        let member = world
+            .spawn((
+                ActorId::new("mesh"),
+                material,
+                HydratedPrefabMember { instance_root },
+                ChildOf(instance_root),
+            ))
+            .id();
+        remove_prefab_component_override::<MaterialDesc>(&mut world, member);
+
+        apply_prefab_member_scope_to_source(
+            &mut world,
+            member,
+            Some(std::any::type_name::<MaterialDesc>()),
+            None,
+        );
+
+        let after_source = std::fs::read_to_string(&source_path).unwrap();
+        let document = SceneDocument::from_ron_text(&after_source).unwrap();
+        assert!(document.entities[0]
+            .components
+            .iter()
+            .all(|component| component.type_name != std::any::type_name::<MaterialDesc>()));
+        assert!(
+            read_overrides(world.get::<PrefabInstance>(instance_root).unwrap())
+                .components
+                .is_empty()
+        );
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            before_source
+        );
+        let restored = read_overrides(world.get::<PrefabInstance>(instance_root).unwrap());
+        assert_eq!(restored.components.len(), 1);
+        assert!(restored.components[0].value_component_ron.is_none());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn structural_remove_apply_is_exact_byte_undoable() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-structural-apply-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let source_path = prefabs.join("hierarchy.scn.ron");
+        let before_source = hierarchy_prefab_source(Transform::from_xyz(1.0, 2.0, 3.0));
+        std::fs::write(&source_path, &before_source).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let instance = PrefabInstance::new("hierarchy", "assets/prefabs/hierarchy.scn.ron");
+        let instance_root = world.spawn(instance.clone()).id();
+        let revision = prefab_source_revision(&root, &instance.source_path).unwrap();
+        write_overrides(
+            &mut world,
+            instance_root,
+            &PrefabOverrides {
+                source_revision: Some(revision.clone()),
+                structural: vec![PrefabStructuralOverride::RemoveChild {
+                    target: PrefabActorPath::direct("child"),
+                    base_subtree_revision: revision,
+                }],
+                ..default()
+            },
+        );
+
+        apply_prefab_instance_overrides_to_source(&mut world, instance_root);
+
+        let after_source = std::fs::read_to_string(&source_path).unwrap();
+        let document = SceneDocument::from_ron_text(&after_source).unwrap();
+        assert!(document
+            .find_entity(&SceneEntityId::ActorId("child".into()))
+            .is_none());
+        assert!(
+            read_overrides(world.get::<PrefabInstance>(instance_root).unwrap())
+                .structural
+                .is_empty()
+        );
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            before_source
+        );
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(instance_root).unwrap())
+                .structural
+                .len(),
+            1
+        );
+        crate::history::apply_command_redo(&mut world);
+        assert_eq!(std::fs::read_to_string(&source_path).unwrap(), after_source);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn reparent_then_transform_edit_applies_in_layer_order_and_undoes() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-reparent-apply-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let source_path = prefabs.join("hierarchy.scn.ron");
+        let before_source = hierarchy_prefab_source(Transform::from_xyz(1.0, 0.0, 0.0));
+        std::fs::write(&source_path, &before_source).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let instance_root = world
+            .spawn(PrefabInstance::new(
+                "hierarchy",
+                "assets/prefabs/hierarchy.scn.ron",
+            ))
+            .id();
+        let parent = world
+            .spawn((
+                ActorId::new("parent"),
+                Transform::default(),
+                GlobalTransform::from_xyz(10.0, 0.0, 0.0),
+                HydratedPrefabMember { instance_root },
+                ChildOf(instance_root),
+            ))
+            .id();
+        let child = world
+            .spawn((
+                ActorId::new("child"),
+                Transform::from_xyz(1.0, 0.0, 0.0),
+                GlobalTransform::from_xyz(11.0, 0.0, 0.0),
+                HydratedPrefabMember { instance_root },
+                ChildOf(parent),
+            ))
+            .id();
+
+        assert!(reparent_prefab_source_child(&mut world, child, None));
+        assert_eq!(world.get::<Transform>(child).unwrap().translation.x, 11.0);
+        set_prefab_transform_property_override(
+            &mut world,
+            child,
+            "translation",
+            Transform::from_xyz(12.0, 0.0, 0.0),
+        );
+        let instance = world.get::<PrefabInstance>(instance_root).unwrap().clone();
+        let overrides = read_overrides(&instance);
+        assert!(prefab_semantic_conflicts(&root, &instance, &overrides).is_empty());
+
+        apply_prefab_actor_path_to_source(
+            &mut world,
+            instance_root,
+            &PrefabActorPath::direct("child"),
+        );
+
+        let after_source = std::fs::read_to_string(&source_path).unwrap();
+        let document = SceneDocument::from_ron_text(&after_source).unwrap();
+        let child_source = document
+            .find_entity(&SceneEntityId::ActorId("child".into()))
+            .unwrap();
+        assert!(child_source.parent_actor_id.is_none());
+        let transform: Transform = ron::from_str(
+            &child_source
+                .components
+                .iter()
+                .find(|component| component.type_name == std::any::type_name::<Transform>())
+                .unwrap()
+                .ron,
+        )
+        .unwrap();
+        assert_eq!(transform.translation.x, 12.0);
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            before_source
+        );
+        let restored = read_overrides(world.get::<PrefabInstance>(instance_root).unwrap());
+        assert_eq!(restored.structural.len(), 1);
+        assert_eq!(restored.properties.len(), 1);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn multi_member_reparent_is_atomic_and_records_one_history_entry() {
+        let mut world = World::new();
+        world.init_resource::<crate::scene_io::SceneIo>();
+        world.init_resource::<crate::history::EditorHistory>();
+        let root = world
+            .spawn(PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron"))
+            .id();
+        let parent = world
+            .spawn((
+                ActorId::new("parent"),
+                GlobalTransform::from_xyz(10.0, 0.0, 0.0),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+                ChildOf(root),
+            ))
+            .id();
+        let first = world
+            .spawn((
+                ActorId::new("first"),
+                Transform::default(),
+                GlobalTransform::from_xyz(1.0, 0.0, 0.0),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+                ChildOf(root),
+            ))
+            .id();
+        let second = world
+            .spawn((
+                ActorId::new("second"),
+                Transform::default(),
+                GlobalTransform::from_xyz(2.0, 0.0, 0.0),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+                ChildOf(root),
+            ))
+            .id();
+
+        assert!(reparent_prefab_source_children(
+            &mut world,
+            &[first, second],
+            Some(parent),
+        ));
+        assert_eq!(
+            world.get::<ChildOf>(first).map(ChildOf::parent),
+            Some(parent)
+        );
+        assert_eq!(
+            world.get::<ChildOf>(second).map(ChildOf::parent),
+            Some(parent)
+        );
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(root).unwrap())
+                .structural
+                .len(),
+            2
+        );
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            1
+        );
+
+        let invalid = world.spawn_empty().id();
+        let before = world.get::<ChildOf>(first).map(ChildOf::parent);
+        assert!(!reparent_prefab_source_children(
+            &mut world,
+            &[first, invalid],
+            None,
+        ));
+        assert_eq!(world.get::<ChildOf>(first).map(ChildOf::parent), before);
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            1
+        );
+    }
+
+    #[test]
+    fn nested_apply_updates_immediate_source_layer() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-nested-apply-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let base_path = prefabs.join("base.scn.ron");
+        let variant_path = prefabs.join("variant.scn.ron");
+        let base_material = MaterialDesc::default();
+        let base_source = prefab_source("mesh", Some(&base_material));
+        std::fs::write(&base_path, &base_source).unwrap();
+        let mut variant_material = base_material.clone();
+        variant_material.roughness = 0.2;
+        let mut nested_instance = PrefabInstance::new("base", "assets/prefabs/base.scn.ron");
+        nested_instance.overrides_ron = encode_prefab_overrides(&PrefabOverrides {
+            properties: vec![PrefabPropertyOverride {
+                target: PrefabActorPath::direct("mesh"),
+                component_type: std::any::type_name::<MaterialDesc>().to_string(),
+                property_path: "roughness".to_string(),
+                base_component_ron: ron::to_string(&base_material).unwrap(),
+                value_component_ron: ron::to_string(&variant_material).unwrap(),
+            }],
+            ..default()
+        })
+        .unwrap();
+        let variant_source = format!(
+            "(schema_version:2,resources:{{}},entities:{{1:(components:{{\"shared::components::LevelObject\":(),\"shared::components::ActorId\":(\"nested\"),\"shared::components::ActorKind\":PrefabAnchor,\"{}\":{},\"{}\":{} }})}})",
+            std::any::type_name::<Transform>(),
+            ron::to_string(&Transform::default()).unwrap(),
+            std::any::type_name::<PrefabInstance>(),
+            ron::to_string(&nested_instance).unwrap(),
+        );
+        std::fs::write(&variant_path, &variant_source).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let outer = world
+            .spawn(PrefabInstance::new(
+                "variant",
+                "assets/prefabs/variant.scn.ron",
+            ))
+            .id();
+        let nested = world
+            .spawn((
+                ActorId::new("nested"),
+                nested_instance.clone(),
+                HydratedPrefabMember {
+                    instance_root: outer,
+                },
+                ChildOf(outer),
+            ))
+            .id();
+        let member = world
+            .spawn((
+                ActorId::new("mesh"),
+                variant_material.clone(),
+                HydratedPrefabMember {
+                    instance_root: nested,
+                },
+                ChildOf(nested),
+            ))
+            .id();
+        let mut overridden = variant_material;
+        overridden.roughness = 0.1;
+        set_prefab_material_property_override(&mut world, member, "roughness", overridden);
+        let outer_instance = world.get::<PrefabInstance>(outer).unwrap().clone();
+        let outer_overrides = read_overrides(&outer_instance);
+        assert!(prefab_semantic_conflicts(&root, &outer_instance, &outer_overrides).is_empty());
+
+        apply_prefab_member_scope_to_source(
+            &mut world,
+            member,
+            Some(std::any::type_name::<MaterialDesc>()),
+            Some("roughness"),
+        );
+
+        assert_eq!(std::fs::read_to_string(&base_path).unwrap(), base_source);
+        let document =
+            SceneDocument::from_ron_text(&std::fs::read_to_string(&variant_path).unwrap()).unwrap();
+        let nested_overrides = decode_prefab_overrides(&document.prefab_instances[0]).unwrap();
+        assert_eq!(nested_overrides.properties.len(), 1);
+        assert!(nested_overrides.properties[0]
+            .target
+            .instance_chain
+            .is_empty());
+        assert_eq!(nested_overrides.properties[0].target.actor_id, "mesh");
+        let preserved_base: MaterialDesc =
+            ron::from_str(&nested_overrides.properties[0].base_component_ron).unwrap();
+        let committed_value: MaterialDesc =
+            ron::from_str(&nested_overrides.properties[0].value_component_ron).unwrap();
+        assert_eq!(preserved_base.roughness, base_material.roughness);
+        assert_eq!(committed_value.roughness, 0.1);
+        let effective = source_component_for_target(
+            &root,
+            world.get::<PrefabInstance>(outer).unwrap(),
+            &PrefabActorPath {
+                instance_chain: vec!["nested".to_string()],
+                actor_id: "mesh".to_string(),
+            },
+            std::any::type_name::<MaterialDesc>(),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            ron::from_str::<MaterialDesc>(&effective.ron)
+                .unwrap()
+                .roughness,
+            0.1
+        );
+        assert!(read_overrides(world.get::<PrefabInstance>(outer).unwrap())
+            .properties
+            .is_empty());
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            std::fs::read_to_string(&variant_path).unwrap(),
+            variant_source
+        );
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(outer).unwrap())
+                .properties
+                .len(),
+            1
+        );
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn source_field_conflict_keeps_override_recoverable() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-source-conflict-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let source_path = prefabs.join("base.scn.ron");
+        let base = MaterialDesc::default();
+        std::fs::write(&source_path, prefab_source("mesh", Some(&base))).unwrap();
+
+        let mut world = prefab_test_world(&root);
+        let instance_root = world
+            .spawn(PrefabInstance::new("base", "assets/prefabs/base.scn.ron"))
+            .id();
+        let member = world
+            .spawn((
+                ActorId::new("mesh"),
+                base.clone(),
+                HydratedPrefabMember { instance_root },
+                ChildOf(instance_root),
+            ))
+            .id();
+        let mut overridden = base.clone();
+        overridden.roughness = 0.1;
+        set_prefab_material_property_override(&mut world, member, "roughness", overridden);
+        let mut externally_changed = base;
+        externally_changed.roughness = 0.4;
+        let changed_source = prefab_source("mesh", Some(&externally_changed));
+        std::fs::write(&source_path, &changed_source).unwrap();
+
+        apply_prefab_member_scope_to_source(
+            &mut world,
+            member,
+            Some(std::any::type_name::<MaterialDesc>()),
+            Some("roughness"),
+        );
+
+        assert_eq!(
+            std::fs::read_to_string(&source_path).unwrap(),
+            changed_source
+        );
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(instance_root).unwrap())
+                .properties
+                .len(),
+            1
+        );
+        assert!(world
+            .resource::<crate::scene_io::SceneIo>()
+            .status
+            .contains("conflict"));
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            1
+        );
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn visibility_component_override_survives_rename_by_actor_path() {
+        let mut world = World::new();
+        world.init_resource::<crate::scene_io::SceneIo>();
+        world.init_resource::<crate::history::EditorHistory>();
+        let root = world
+            .spawn((
+                LevelObject,
+                PrefabInstance::new("prefab-id", "assets/prefabs/test.scn.ron"),
+            ))
+            .id();
+        let child = world
+            .spawn((
+                LevelObject,
+                ActorId::new("stable-child"),
+                Name::new("Old Name"),
+                EditorVisibility { visible: false },
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+
+        set_child_visibility_override(&mut world, root, child, false);
+        let overrides = read_overrides(world.get::<PrefabInstance>(root).unwrap());
+        assert!(overrides.child_visibility.is_empty());
+        assert_eq!(overrides.components.len(), 1);
+        assert_eq!(
+            overrides.components[0].target,
+            PrefabActorPath::direct("stable-child")
+        );
+        assert_eq!(
+            overrides.components[0].component_type,
+            std::any::type_name::<EditorVisibility>()
+        );
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            1
+        );
+
+        crate::history::apply_command_undo(&mut world);
+        assert!(read_overrides(world.get::<PrefabInstance>(root).unwrap())
+            .components
+            .is_empty());
+        crate::history::apply_command_redo(&mut world);
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(root).unwrap()).components[0].target,
+            PrefabActorPath::direct("stable-child")
+        );
+
+        world.entity_mut(child).insert(Name::new("Renamed Child"));
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(root).unwrap()).components[0].target,
+            PrefabActorPath::direct("stable-child")
+        );
+
+        revert_child_visibility_overrides(&mut world, root);
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            2
+        );
+        assert!(world.get::<EditorVisibility>(child).is_none());
+        assert!(read_overrides(world.get::<PrefabInstance>(root).unwrap())
+            .components
+            .is_empty());
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(root).unwrap()).components[0].target,
+            PrefabActorPath::direct("stable-child")
+        );
+        crate::history::apply_command_redo(&mut world);
+        assert!(read_overrides(world.get::<PrefabInstance>(root).unwrap())
+            .components
+            .is_empty());
+    }
+
+    #[test]
+    fn nested_visibility_overrides_distinguish_repeated_leaf_actor_ids() {
+        let mut world = World::new();
+        world.init_resource::<crate::scene_io::SceneIo>();
+        world.init_resource::<crate::history::EditorHistory>();
+        let root = world
+            .spawn(PrefabInstance::new("outer", "assets/prefabs/outer.scn.ron"))
+            .id();
+        let nested_a = world
+            .spawn((
+                ActorId::new("nested-a"),
+                PrefabInstance::new("leaf", "assets/prefabs/leaf.scn.ron"),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+                ChildOf(root),
+            ))
+            .id();
+        let nested_b = world
+            .spawn((
+                ActorId::new("nested-b"),
+                PrefabInstance::new("leaf", "assets/prefabs/leaf.scn.ron"),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+                ChildOf(root),
+            ))
+            .id();
+        let leaf_a = world
+            .spawn((
+                ActorId::new("shared-leaf"),
+                EditorVisibility::default(),
+                HydratedPrefabMember {
+                    instance_root: nested_a,
+                },
+                ChildOf(nested_a),
+            ))
+            .id();
+        let leaf_b = world
+            .spawn((
+                ActorId::new("shared-leaf"),
+                EditorVisibility::default(),
+                HydratedPrefabMember {
+                    instance_root: nested_b,
+                },
+                ChildOf(nested_b),
+            ))
+            .id();
+
+        set_child_visibility_override(&mut world, root, leaf_a, false);
+        set_child_visibility_override(&mut world, root, leaf_b, false);
+
+        let overrides = read_overrides(world.get::<PrefabInstance>(root).unwrap());
+        let targets: HashSet<_> = overrides
+            .components
+            .iter()
+            .map(|component| component.target.clone())
+            .collect();
+        assert_eq!(targets.len(), 2);
+        assert!(targets.contains(&PrefabActorPath {
+            instance_chain: vec!["nested-a".to_string()],
+            actor_id: "shared-leaf".to_string(),
+        }));
+        assert!(targets.contains(&PrefabActorPath {
+            instance_chain: vec!["nested-b".to_string()],
+            actor_id: "shared-leaf".to_string(),
+        }));
+
+        crate::history::apply_command_undo(&mut world);
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(root).unwrap())
+                .components
+                .len(),
+            1
+        );
+        crate::history::apply_command_redo(&mut world);
+        assert_eq!(
+            read_overrides(world.get::<PrefabInstance>(root).unwrap())
+                .components
+                .len(),
+            2
+        );
+    }
+
+    #[test]
+    fn ready_instance_reapplies_child_visibility_by_actor_id() {
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
+            .register_type::<ActorId>()
+            .add_observer(shared::apply_prefab_overrides_on_ready);
+
+        let mut source = World::new();
+        source.spawn(ActorId::new("stable-child"));
+        let dynamic_world = DynamicWorld::from_world_with(
+            &source,
+            &app.world().resource::<AppTypeRegistry>().read(),
+        );
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(dynamic_world);
+        let root = app
+            .world_mut()
+            .spawn((
+                PrefabInstance::new("prefab-id", "assets/prefabs/test.scn.ron"),
+                DynamicWorldRoot(handle),
+            ))
+            .id();
+        write_overrides(
+            app.world_mut(),
+            root,
+            &PrefabOverrides {
+                child_visibility: HashMap::from([("stable-child".to_string(), false)]),
+                ..default()
+            },
+        );
+
+        app.update();
+
+        let world = app.world_mut();
+        let (_, visibility) = world
+            .query::<(&ActorId, &EditorVisibility)>()
+            .single(world)
+            .expect("ready observer should apply the stable child override");
+        assert!(!visibility.visible);
+    }
+
+    #[test]
+    fn invalid_reimport_cleanup_allows_single_clean_retry() {
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
+            .register_type::<ActorId>();
+
+        let mut source = World::new();
+        source.spawn(ActorId::new("source-child"));
+        let dynamic_world = DynamicWorld::from_world_with(
+            &source,
+            &app.world().resource::<AppTypeRegistry>().read(),
+        );
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(dynamic_world);
+        let root = app
+            .world_mut()
+            .spawn((
+                PrefabInstance::new("prefab-id", "assets/prefabs/test.scn.ron"),
+                DynamicWorldRoot(handle.clone()),
+            ))
+            .id();
+        app.update();
+
+        let first_instance = **app
+            .world()
+            .get::<WorldInstance>(root)
+            .expect("initial prefab should be registered");
+        let first_members: Vec<_> = app
+            .world()
+            .resource::<WorldInstanceSpawner>()
+            .iter_instance_entities(first_instance)
+            .collect();
+        assert_eq!(first_members.len(), 1);
+        for member in first_members {
+            app.world_mut()
+                .entity_mut(member)
+                .insert(HydratedPrefabMember {
+                    instance_root: root,
+                });
+        }
+
+        block_prefab_hydration(app.world_mut(), root, "invalid source".to_string());
+
+        assert!(app.world().get::<DynamicWorldRoot>(root).is_none());
+        assert!(app.world().get::<WorldInstance>(root).is_none());
+        assert!(app
+            .world()
+            .get::<shared::PrefabHydrationBlocked>(root)
+            .is_some());
+        assert_eq!(
+            app.world_mut()
+                .query::<&HydratedPrefabMember>()
+                .iter(app.world())
+                .count(),
+            0
+        );
+        assert!(!app
+            .world()
+            .resource::<WorldInstanceSpawner>()
+            .instance_is_ready(first_instance));
+
+        app.world_mut()
+            .entity_mut(root)
+            .remove::<shared::PrefabHydrationBlocked>()
+            .insert(DynamicWorldRoot(handle));
+        app.update();
+
+        let repaired_instance = **app
+            .world()
+            .get::<WorldInstance>(root)
+            .expect("repaired prefab should register a fresh instance");
+        let repaired_members: Vec<_> = app
+            .world()
+            .resource::<WorldInstanceSpawner>()
+            .iter_instance_entities(repaired_instance)
+            .collect();
+        assert_ne!(repaired_instance, first_instance);
+        assert_eq!(repaired_members.len(), 1);
+        assert_eq!(
+            app.world_mut()
+                .query::<&ActorId>()
+                .iter(app.world())
+                .count(),
+            1,
+            "retry must not duplicate generated source state"
+        );
+    }
+
+    #[test]
+    fn removed_asset_event_blocks_prefab_and_cleans_generated_state() {
+        let project_root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-removed-event-{}",
+            uuid::Uuid::new_v4()
+        ));
+        std::fs::create_dir_all(project_root.join("assets/prefabs")).unwrap();
+        std::fs::write(project_root.join("assets/project.ron"), "()").unwrap();
+
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
+            .init_resource::<crate::scene_io::SceneIo>()
+            .insert_resource(crate::project_io::ProjectWorkspace {
+                root: project_root.display().to_string(),
+                ..Default::default()
+            })
+            .add_systems(Update, guard_prefab_reimports);
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(DynamicWorld::default());
+        let root = app
+            .world_mut()
+            .spawn((
+                DynamicWorldRoot(handle.clone()),
+                PrefabInstance::new("missing", "assets/prefabs/missing.scn.ron"),
+            ))
+            .id();
+        let generated = app
+            .world_mut()
+            .spawn(HydratedPrefabMember {
+                instance_root: root,
+            })
+            .id();
+        app.world_mut()
+            .resource_mut::<Messages<AssetEvent<DynamicWorld>>>()
+            .write(AssetEvent::Removed { id: handle.id() });
+
+        app.update();
+
+        assert!(app.world().get_entity(generated).is_err());
+        assert!(app
+            .world()
+            .get::<shared::PrefabHydrationBlocked>(root)
+            .is_some());
+        assert!(app.world().get::<DynamicWorldRoot>(root).is_none());
+        std::fs::remove_dir_all(project_root).unwrap();
+    }
+
+    #[test]
+    fn nested_invalid_reimport_blocks_top_authored_owner() {
+        let mut world = World::new();
+        let root = world
+            .spawn((
+                PrefabInstance::new("outer", "assets/prefabs/outer.scn.ron"),
+                DynamicWorldRoot::default(),
+            ))
+            .id();
+        let nested = world
+            .spawn((
+                PrefabInstance::new("nested", "assets/prefabs/nested.scn.ron"),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        let nested_child = world
+            .spawn(HydratedPrefabMember {
+                instance_root: nested,
+            })
+            .id();
+
+        block_prefab_hydration(&mut world, nested, "nested source invalid".to_string());
+
+        assert!(world
+            .get::<shared::PrefabHydrationBlocked>(root)
+            .is_some_and(|blocked| blocked.reason == "nested source invalid"));
+        assert!(world.get::<DynamicWorldRoot>(root).is_none());
+        assert!(world.get_entity(nested).is_err());
+        assert!(world.get_entity(nested_child).is_err());
+    }
 }
diff --git a/crates/editor/src/assets/thumbnails/cache.rs b/crates/editor/src/assets/thumbnails/cache.rs
index e50eaac..3de9eff 100644
--- a/crates/editor/src/assets/thumbnails/cache.rs
+++ b/crates/editor/src/assets/thumbnails/cache.rs
@@ -120,6 +120,7 @@ impl AssetThumbnailCache {
         model_path: String,
         mesh_label: String,
         material_label: Option<String>,
+        requires_scene_instance: bool,
         studio: &mut ThumbnailStudio,
     ) {
         if matches!(
@@ -132,14 +133,16 @@ impl AssetThumbnailCache {
         if !self.model_source_ready(&key, &model_path) {
             return;
         }
-        if studio.enqueue_source(
-            key.clone(),
+        let source = if requires_scene_instance {
+            ThumbnailJobSource::Model { model_path }
+        } else {
             ThumbnailJobSource::MeshSubAsset {
                 model_path,
                 mesh_label,
                 material_label,
-            },
-        ) {
+            }
+        };
+        if studio.enqueue_source(key.clone(), source) {
             self.studio_pending.insert(key);
         }
     }
@@ -292,6 +295,7 @@ pub fn kind_icon(kind: &EditorAssetKind) -> egui_phosphor_icons::Icon {
         EditorAssetKind::Model => icons::CUBE_TRANSPARENT,
         EditorAssetKind::Texture => icons::IMAGE,
         EditorAssetKind::Material => icons::PAINT_BRUSH,
+        EditorAssetKind::AudioClip => icons::WAVEFORM,
         EditorAssetKind::Level => icons::MAP_TRIFOLD,
         EditorAssetKind::Prefab => icons::PACKAGE,
         EditorAssetKind::PostProcessVolume => icons::CAMERA,
diff --git a/crates/editor/src/assets/thumbnails/mod.rs b/crates/editor/src/assets/thumbnails/mod.rs
index 988e388..c28f54c 100644
--- a/crates/editor/src/assets/thumbnails/mod.rs
+++ b/crates/editor/src/assets/thumbnails/mod.rs
@@ -12,7 +12,9 @@ pub use cache::{
     AssetThumbnailCache, AssetThumbnailsPlugin, ThumbnailCacheSnapshot, ThumbnailState,
 };
 pub use job::{ThumbnailJob, ThumbnailJobSource};
-pub use sources::{FbxThumbnailSource, GltfThumbnailSource, ThumbnailModelSource};
+pub use sources::{
+    gltf_skinned_primitive_labels, FbxThumbnailSource, GltfThumbnailSource, ThumbnailModelSource,
+};
 pub use studio::{
     model_file_exists, model_scene_asset_path, ThumbnailStudio, ThumbnailStudioPlugin,
 };
diff --git a/crates/editor/src/assets/thumbnails/sources/gltf.rs b/crates/editor/src/assets/thumbnails/sources/gltf.rs
index 088c48a..9c36594 100644
--- a/crates/editor/src/assets/thumbnails/sources/gltf.rs
+++ b/crates/editor/src/assets/thumbnails/sources/gltf.rs
@@ -1,5 +1,6 @@
 //! glTF/GLB fast-path texture extraction for asset browser thumbnails.
 
+use std::collections::HashSet;
 use std::path::Path;
 
 /// Returns an asset-server path for the first base-color texture referenced by a glTF/GLB file.
@@ -64,6 +65,32 @@ pub fn validate_gltf_dependencies(model_asset_path: &str) -> Result<(), String>
     Ok(())
 }
 
+/// Returns primitive labels that cannot be rendered without their source skin hierarchy.
+pub fn gltf_skinned_primitive_labels(model_asset_path: &str) -> HashSet<String> {
+    let model_path = Path::new(model_asset_path);
+    if !is_gltf_path(model_path) {
+        return HashSet::new();
+    }
+    let Ok(gltf) = gltf::Gltf::open(model_path) else {
+        return HashSet::new();
+    };
+    gltf.meshes()
+        .flat_map(|mesh| {
+            let mesh_index = mesh.index();
+            mesh.primitives()
+                .filter(|primitive| {
+                    primitive.attributes().any(|(semantic, _)| {
+                        matches!(
+                            semantic,
+                            gltf::Semantic::Joints(_) | gltf::Semantic::Weights(_)
+                        )
+                    })
+                })
+                .map(move |primitive| format!("Mesh{mesh_index}/Primitive{}", primitive.index()))
+        })
+        .collect()
+}
+
 pub struct GltfThumbnailSource;
 
 fn is_gltf_path(path: &Path) -> bool {
@@ -137,4 +164,16 @@ mod tests {
 
         fs::remove_dir_all(directory).unwrap();
     }
+
+    #[test]
+    fn committed_robot_fixture_identifies_skinned_primitives() {
+        let path =
+            Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/models/robot_expressive.glb");
+        let labels = gltf_skinned_primitive_labels(path.to_str().unwrap());
+
+        assert!(labels.contains("Mesh12/Primitive0"));
+        assert!(labels.contains("Mesh13/Primitive0"));
+        assert!(!labels.contains("Mesh0/Primitive0"));
+        assert!(!labels.contains("Mesh999/Primitive0"));
+    }
 }
diff --git a/crates/editor/src/assets/thumbnails/sources/mod.rs b/crates/editor/src/assets/thumbnails/sources/mod.rs
index b83e999..470792f 100644
--- a/crates/editor/src/assets/thumbnails/sources/mod.rs
+++ b/crates/editor/src/assets/thumbnails/sources/mod.rs
@@ -4,7 +4,7 @@ mod fbx;
 pub(crate) mod gltf;
 
 pub use fbx::FbxThumbnailSource;
-pub use gltf::GltfThumbnailSource;
+pub use gltf::{gltf_skinned_primitive_labels, GltfThumbnailSource};
 
 use bevy::prelude::*;
 
diff --git a/crates/editor/src/assets/thumbnails/studio.rs b/crates/editor/src/assets/thumbnails/studio.rs
index 108df7f..6792577 100644
--- a/crates/editor/src/assets/thumbnails/studio.rs
+++ b/crates/editor/src/assets/thumbnails/studio.rs
@@ -11,7 +11,7 @@ use bevy::mesh::VertexAttributeValues;
 use bevy::prelude::*;
 use bevy::render::render_resource::TextureFormat;
 use bevy_egui::EguiUserTextures;
-use shared::{material_from_desc, ModelRef};
+use shared::{material_from_desc, standard_material_asset_path, ModelRef};
 
 use super::cache::AssetThumbnailCache;
 use super::job::{ThumbnailJob, ThumbnailJobSource};
@@ -413,7 +413,7 @@ fn spawn_thumbnail_job_content(
             commands,
             mesh_storage,
             root,
-            asset_server.load(labeled_asset_path(
+            asset_server.load(standard_material_asset_path(
                 &asset_server_path(model_path),
                 material_label,
             )),
@@ -437,7 +437,7 @@ fn spawn_mesh_subasset_preview(
     let source_path = asset_server_path(model_path);
     let mesh: Handle<Mesh> = asset_server.load(labeled_asset_path(&source_path, mesh_label));
     let material = if let Some(material_label) = material_label {
-        asset_server.load(labeled_asset_path(&source_path, material_label))
+        asset_server.load(standard_material_asset_path(&source_path, material_label))
     } else {
         materials.add(StandardMaterial {
             base_color: Color::srgb(0.72, 0.72, 0.75),
diff --git a/crates/editor/src/bin/main.rs b/crates/editor/src/bin/main.rs
index bd3fce6..9d7609e 100644
--- a/crates/editor/src/bin/main.rs
+++ b/crates/editor/src/bin/main.rs
@@ -1,6 +1,27 @@
 //! In-process editor binary entry point.
 
 fn main() {
+    let startup = match editor::launcher::parse_startup_arguments(std::env::args().skip(1)) {
+        Ok(startup) => startup,
+        Err(error) => {
+            eprintln!(
+                "Blacksite Editor: {error}\n\n{}",
+                editor::launcher::command_line_help()
+            );
+            std::process::exit(2);
+        }
+    };
+    if startup.help {
+        println!("{}", editor::launcher::command_line_help());
+        return;
+    }
+    if let Some(root) = startup.project {
+        if let Err(error) = editor::launcher::activate_project_root(&root) {
+            eprintln!("Blacksite Editor: {error}");
+            std::process::exit(2);
+        }
+    }
+
     if std::env::var_os("WGPU_VALIDATION").is_none() {
         // SAFETY: called before any threads or GPU init.
         unsafe { std::env::set_var("WGPU_VALIDATION", "0") };
diff --git a/crates/editor/src/bin/project_launcher.rs b/crates/editor/src/bin/project_launcher.rs
new file mode 100644
index 0000000..d5d536d
--- /dev/null
+++ b/crates/editor/src/bin/project_launcher.rs
@@ -0,0 +1,9 @@
+//! Dedicated pre-engine Blacksite project browser.
+
+fn main() {
+    if std::env::var_os("WGPU_VALIDATION").is_none() {
+        // SAFETY: called before Bevy starts worker threads or initializes the renderer.
+        unsafe { std::env::set_var("WGPU_VALIDATION", "0") };
+    }
+    editor::launcher::run_project_launcher();
+}
diff --git a/crates/editor/src/history/commands.rs b/crates/editor/src/history/commands.rs
index 1ce3c42..392859f 100644
--- a/crates/editor/src/history/commands.rs
+++ b/crates/editor/src/history/commands.rs
@@ -1,8 +1,11 @@
+use std::path::PathBuf;
+
 use bevy::prelude::*;
 use shared::{
-    ActorId, ActorKind, ActorName, BrushDesc, ColliderDesc, EditorVisibility, InspectorOrder,
-    LightDesc, MaterialDesc, MaterialOverride, ModelRef, ObjectiveMarker, PhysicsBody,
-    PostProcessVolumeDesc, PrefabInstance, PrefabRef, Primitive, RigidBodyDesc, StaticMeshRenderer,
+    ActorId, ActorKind, ActorName, AnimationControllerDesc, AudioListenerDesc, AudioSourceDesc,
+    BrushDesc, ColliderDesc, EditorVisibility, InspectorOrder, LightDesc, MaterialDesc,
+    MaterialOverride, ModelRef, ObjectiveMarker, PhysicsBody, PostProcessVolumeDesc,
+    PrefabInstance, PrefabRef, Primitive, RigidBodyDesc, SceneComposition, StaticMeshRenderer,
     TeamSpawn, TriggerVolume, WeaponSpawn,
 };
 #[derive(Debug, Clone)]
@@ -21,6 +24,9 @@ pub struct EditorEntitySnapshot {
     pub collider: Option<ColliderDesc>,
     pub physics: Option<PhysicsBody>,
     pub light: Option<LightDesc>,
+    pub animation_controller: Option<AnimationControllerDesc>,
+    pub audio_source: Option<AudioSourceDesc>,
+    pub audio_listener: Option<AudioListenerDesc>,
     pub player_spawn: bool,
     pub model: Option<ModelRef>,
     pub prefab: Option<PrefabRef>,
@@ -42,6 +48,17 @@ pub struct SiblingChange {
     pub new_parent: Option<Entity>,
     pub old_index: i32,
     pub new_index: i32,
+    pub old_transform: Option<Transform>,
+    pub new_transform: Option<Transform>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct PrefabEditState {
+    pub instance: Option<PrefabInstance>,
+    pub prefab_ref: Option<PrefabRef>,
+    pub blocked_reason: Option<String>,
+    pub transform: Option<Transform>,
+    pub material: Option<MaterialDesc>,
 }
 
 #[derive(Debug, Clone)]
@@ -77,6 +94,11 @@ pub enum EditorCommand {
         old: Option<MaterialDesc>,
         new: MaterialDesc,
     },
+    SetMaterialGroup {
+        entities: Vec<Entity>,
+        olds: Vec<Option<MaterialDesc>>,
+        news: Vec<MaterialDesc>,
+    },
     SetMaterialOverride {
         entity: Entity,
         old: Option<MaterialOverride>,
@@ -87,6 +109,21 @@ pub enum EditorCommand {
         old: Option<LightDesc>,
         new: LightDesc,
     },
+    SetAnimationController {
+        entity: Entity,
+        old: Option<AnimationControllerDesc>,
+        new: AnimationControllerDesc,
+    },
+    SetAudioSource {
+        entity: Entity,
+        old: Option<AudioSourceDesc>,
+        new: AudioSourceDesc,
+    },
+    SetAudioListener {
+        entity: Entity,
+        old: Option<AudioListenerDesc>,
+        new: AudioListenerDesc,
+    },
     SetPhysics {
         entity: Entity,
         old: Option<PhysicsBody>,
@@ -165,6 +202,35 @@ pub enum EditorCommand {
         old: Option<InspectorOrder>,
         new: InspectorOrder,
     },
+    SetSceneComposition {
+        old: SceneComposition,
+        new: SceneComposition,
+    },
+    SetPrefabState {
+        entity: Entity,
+        old: PrefabEditState,
+        new: PrefabEditState,
+    },
+    ApplyPrefabToSource {
+        entity: Entity,
+        source_path: PathBuf,
+        before_source: String,
+        after_source: String,
+        old: PrefabEditState,
+        new: PrefabEditState,
+    },
+    UnpackPrefab {
+        entity: Entity,
+        instance: PrefabInstance,
+        prefab_ref: PrefabRef,
+        linked_actor_kind: ActorKind,
+        fully_local: bool,
+        linked_local_snapshots: Vec<EditorEntitySnapshot>,
+        linked_local_roots: Vec<Entity>,
+        unpacked_snapshots: Vec<EditorEntitySnapshot>,
+        unpacked_parented_to_anchor: Vec<bool>,
+        unpacked_roots: Vec<Entity>,
+    },
     AddComponent {
         entity: Entity,
         snapshot: EditorEntitySnapshot,
@@ -185,8 +251,12 @@ impl EditorCommand {
             EditorCommand::Rename { .. } => "Rename",
             EditorCommand::SetTransform { .. } => "Move",
             EditorCommand::SetMaterial { .. } => "Set Material",
+            EditorCommand::SetMaterialGroup { .. } => "Apply Material to Selection",
             EditorCommand::SetMaterialOverride { .. } => "Set Material Override",
             EditorCommand::SetLight { .. } => "Set Light",
+            EditorCommand::SetAnimationController { .. } => "Set Animation Controller",
+            EditorCommand::SetAudioSource { .. } => "Set Audio Source",
+            EditorCommand::SetAudioListener { .. } => "Set Audio Listener",
             EditorCommand::SetPhysics { .. } => "Set Physics",
             EditorCommand::SetRigidBody { .. } => "Set Rigid Body",
             EditorCommand::SetCollider { .. } => "Set Collider",
@@ -202,6 +272,15 @@ impl EditorCommand {
             EditorCommand::ReorderSibling { .. } => "Reorder Hierarchy",
             EditorCommand::SetEditorVisibility { .. } => "Set Visibility",
             EditorCommand::SetInspectorOrder { .. } => "Set Component Order",
+            EditorCommand::SetSceneComposition { .. } => "Set Scene Composition",
+            EditorCommand::SetPrefabState { .. } => "Edit Prefab Instance",
+            EditorCommand::ApplyPrefabToSource { .. } => "Apply Prefab to Source",
+            EditorCommand::UnpackPrefab {
+                fully_local: true, ..
+            } => "Convert Prefab to Local",
+            EditorCommand::UnpackPrefab {
+                fully_local: false, ..
+            } => "Unpack Prefab Layer",
             EditorCommand::AddComponent { .. } => "Add Component",
             EditorCommand::RemoveComponent { .. } => "Remove Component",
         }
diff --git a/crates/editor/src/history/mod.rs b/crates/editor/src/history/mod.rs
index d60de83..43a0901 100644
--- a/crates/editor/src/history/mod.rs
+++ b/crates/editor/src/history/mod.rs
@@ -1,22 +1,28 @@
+use std::collections::HashSet;
+
 use bevy::prelude::*;
+use bevy::world_serialization::WorldInstance;
 use shared::{
-    infer_actor_kind, ActorId, ActorKind, ActorName, BrushDesc, ColliderDesc, EditorVisibility,
-    HierarchySiblingIndex, InspectorOrder, LevelObject, LightDesc, MaterialDesc, MaterialOverride,
-    ModelRef, ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabInstance,
-    PrefabRef, Primitive, RigidBodyDesc, StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
+    infer_actor_kind, ActorId, ActorKind, ActorName, AnimationControllerDesc, AudioListenerDesc,
+    AudioSourceDesc, BrushDesc, ColliderDesc, EditorVisibility, HierarchySiblingIndex,
+    HydratedPrefabMember, HydratedPrefabReady, InspectorOrder, LevelObject, LightDesc,
+    MaterialDesc, MaterialOverride, ModelRef, ObjectiveMarker, PhysicsBody, PlayerSpawn,
+    PostProcessVolumeDesc, PrefabHydrationBlocked, PrefabInstance, PrefabRef, Primitive,
+    RigidBodyDesc, SceneComposition, StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
 };
 
-use crate::scene_io::SceneIo;
+use crate::scene_io::{SceneIo, SceneIoRequest};
 use crate::selection::SelectedEntity;
 use crate::state::scene_tools_active;
 use crate::ui::hierarchy_ops::{
-    apply_sibling_change, apply_sibling_change_new, next_sibling_index,
-    reorder_entities_under_parent, would_create_cycle,
+    apply_sibling_change, apply_sibling_change_new, hierarchy_drop_violation, next_sibling_index,
+    reorder_entities_under_parent,
 };
+use crate::ui::selection_ops::is_mutable_level_object;
 use crate::ui::{egui_captures_keyboard_from_world, UiState};
 
 mod commands;
-pub use commands::{EditorCommand, EditorEntitySnapshot, SiblingChange};
+pub use commands::{EditorCommand, EditorEntitySnapshot, PrefabEditState, SiblingChange};
 
 #[derive(Resource, Debug, Default)]
 pub struct EditorHistory {
@@ -98,7 +104,10 @@ impl Plugin for EditorHistoryPlugin {
 
 pub fn snapshot_entity(world: &World, entity: Entity) -> Option<EditorEntitySnapshot> {
     let entity_ref = world.get_entity(entity).ok()?;
-    if !entity_ref.contains::<LevelObject>() {
+    if !entity_ref.contains::<LevelObject>()
+        || entity_ref.contains::<HydratedPrefabMember>()
+        || entity_ref.contains::<crate::scene_io::ComposedSceneMember>()
+    {
         return None;
     }
 
@@ -135,6 +144,9 @@ pub fn snapshot_entity(world: &World, entity: Entity) -> Option<EditorEntitySnap
         collider: entity_ref.get::<ColliderDesc>().cloned(),
         physics: entity_ref.get::<PhysicsBody>().cloned(),
         light: entity_ref.get::<LightDesc>().cloned(),
+        animation_controller: entity_ref.get::<AnimationControllerDesc>().cloned(),
+        audio_source: entity_ref.get::<AudioSourceDesc>().cloned(),
+        audio_listener: entity_ref.get::<AudioListenerDesc>().copied(),
         player_spawn: entity_ref.contains::<PlayerSpawn>(),
         model: entity_ref.get::<ModelRef>().cloned(),
         prefab: entity_ref.get::<PrefabRef>().cloned(),
@@ -210,6 +222,15 @@ fn spawn_snapshot_with_parent(
     if let Some(light) = &snapshot.light {
         entity_mut.insert(light.clone());
     }
+    if let Some(controller) = &snapshot.animation_controller {
+        entity_mut.insert(controller.clone());
+    }
+    if let Some(audio_source) = &snapshot.audio_source {
+        entity_mut.insert(audio_source.clone());
+    }
+    if let Some(audio_listener) = snapshot.audio_listener {
+        entity_mut.insert(audio_listener);
+    }
     if snapshot.player_spawn {
         entity_mut.insert(PlayerSpawn);
     }
@@ -303,6 +324,9 @@ pub fn spawn_many_with_history(
 pub fn delete_entities_with_history(world: &mut World, entities: &[Entity]) {
     let mut deleted = Vec::new();
     for entity in entities {
+        if !is_mutable_level_object(world, *entity) {
+            continue;
+        }
         if let Some(snapshot) = snapshot_entity(world, *entity) {
             deleted.push((snapshot, *entity));
         }
@@ -329,8 +353,10 @@ pub fn delete_entities_with_history(world: &mut World, entities: &[Entity]) {
 pub fn duplicate_entities_with_history(world: &mut World, entities: &[Entity]) {
     let snapshots: Vec<EditorEntitySnapshot> = entities
         .iter()
+        .filter(|entity| is_mutable_level_object(world, **entity))
         .filter_map(|entity| snapshot_entity(world, *entity))
         .map(|mut snapshot| {
+            assign_fresh_actor_ids(&mut snapshot);
             snapshot.transform.translation += Vec3::new(1.0, 0.0, 1.0);
             if let Some(name) = &mut snapshot.name {
                 name.push_str(" Copy");
@@ -357,7 +383,17 @@ pub fn duplicate_entities_with_history(world: &mut World, entities: &[Entity]) {
     select_many(world, &entities);
 }
 
+fn assign_fresh_actor_ids(snapshot: &mut EditorEntitySnapshot) {
+    snapshot.actor_id = Some(new_actor_id());
+    for child in &mut snapshot.children {
+        assign_fresh_actor_ids(child);
+    }
+}
+
 pub fn rename_entity_with_history(world: &mut World, entity: Entity, new_name: String) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
     let old = world
         .get::<Name>(entity)
         .map(|name| name.as_str().to_string())
@@ -379,7 +415,7 @@ pub fn rename_entity_with_history(world: &mut World, entity: Entity, new_name: S
 }
 
 pub fn set_material_with_history(world: &mut World, entity: Entity, new: MaterialDesc) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<MaterialDesc>(entity).cloned();
@@ -392,11 +428,48 @@ pub fn set_material_with_history(world: &mut World, entity: Entity, new: Materia
     push_history(world, EditorCommand::SetMaterial { entity, old, new });
 }
 
+pub fn set_material_group_with_history(
+    world: &mut World,
+    changes: impl IntoIterator<Item = (Entity, MaterialDesc)>,
+) {
+    let mut entities = Vec::new();
+    let mut olds = Vec::new();
+    let mut news = Vec::new();
+    for (entity, new) in changes {
+        if !is_mutable_level_object(world, entity) {
+            continue;
+        }
+        let old = world.get::<MaterialDesc>(entity).cloned();
+        if old.as_ref().is_some_and(|old| material_eq(old, &new)) {
+            continue;
+        }
+        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.insert(new.clone());
+            entities.push(entity);
+            olds.push(old);
+            news.push(new);
+        }
+    }
+    if !entities.is_empty() {
+        push_history(
+            world,
+            EditorCommand::SetMaterialGroup {
+                entities,
+                olds,
+                news,
+            },
+        );
+    }
+}
+
 pub fn set_material_override_with_history(
     world: &mut World,
     entity: Entity,
     new: MaterialOverride,
 ) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
     let old = world.get::<MaterialOverride>(entity).cloned();
     if old.as_ref() == Some(&new) {
         return;
@@ -411,7 +484,7 @@ pub fn set_material_override_with_history(
 }
 
 pub fn set_light_with_history(world: &mut World, entity: Entity, new: LightDesc) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<LightDesc>(entity).cloned();
@@ -421,12 +494,61 @@ pub fn set_light_with_history(world: &mut World, entity: Entity, new: LightDesc)
     push_history(world, EditorCommand::SetLight { entity, old, new });
 }
 
+pub fn set_audio_source_with_history(world: &mut World, entity: Entity, new: AudioSourceDesc) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
+    let old = world.get::<AudioSourceDesc>(entity).cloned();
+    if old.as_ref() == Some(&new) {
+        return;
+    }
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        entity_mut.insert(new.clone());
+    }
+    push_history(world, EditorCommand::SetAudioSource { entity, old, new });
+}
+
+pub fn set_animation_controller_with_history(
+    world: &mut World,
+    entity: Entity,
+    new: AnimationControllerDesc,
+) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
+    let old = world.get::<AnimationControllerDesc>(entity).cloned();
+    if old.as_ref() == Some(&new) {
+        return;
+    }
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        entity_mut.insert(new.clone());
+    }
+    push_history(
+        world,
+        EditorCommand::SetAnimationController { entity, old, new },
+    );
+}
+
+pub fn set_audio_listener_with_history(world: &mut World, entity: Entity, new: AudioListenerDesc) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
+    let old = world.get::<AudioListenerDesc>(entity).copied();
+    if old == Some(new) {
+        return;
+    }
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        entity_mut.insert(new);
+    }
+    push_history(world, EditorCommand::SetAudioListener { entity, old, new });
+}
+
 pub fn set_post_process_volume_with_history(
     world: &mut World,
     entity: Entity,
     new: PostProcessVolumeDesc,
 ) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<PostProcessVolumeDesc>(entity).cloned();
@@ -440,7 +562,7 @@ pub fn set_post_process_volume_with_history(
 }
 
 pub fn set_physics_with_history(world: &mut World, entity: Entity, new: PhysicsBody) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<PhysicsBody>(entity).cloned();
@@ -451,6 +573,9 @@ pub fn set_physics_with_history(world: &mut World, entity: Entity, new: PhysicsB
 }
 
 pub fn set_rigid_body_with_history(world: &mut World, entity: Entity, new: RigidBodyDesc) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
     let old = world.get::<RigidBodyDesc>(entity).copied();
     if old == Some(new) {
         return;
@@ -462,6 +587,9 @@ pub fn set_rigid_body_with_history(world: &mut World, entity: Entity, new: Rigid
 }
 
 pub fn set_collider_with_history(world: &mut World, entity: Entity, new: ColliderDesc) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
     let old = world.get::<ColliderDesc>(entity).cloned();
     if old.as_ref() == Some(&new) {
         return;
@@ -473,7 +601,7 @@ pub fn set_collider_with_history(world: &mut World, entity: Entity, new: Collide
 }
 
 pub fn set_primitive_with_history(world: &mut World, entity: Entity, new: Primitive) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<Primitive>(entity).cloned();
@@ -484,7 +612,7 @@ pub fn set_primitive_with_history(world: &mut World, entity: Entity, new: Primit
 }
 
 pub fn set_brush_with_history(world: &mut World, entity: Entity, new: BrushDesc) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<BrushDesc>(entity).cloned();
@@ -503,7 +631,7 @@ pub fn set_brush_transform_with_history(
     new_transform: Transform,
     new_brush: BrushDesc,
 ) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old_transform = world.get::<Transform>(entity).copied().unwrap_or_default();
@@ -578,7 +706,7 @@ pub fn set_static_mesh_renderer_with_history(
     entity: Entity,
     new: StaticMeshRenderer,
 ) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<StaticMeshRenderer>(entity).cloned();
@@ -607,12 +735,22 @@ pub fn reorder_siblings_with_history(
     let entities: Vec<Entity> = entities
         .iter()
         .copied()
-        .filter(|entity| is_level_object(world, *entity))
+        .filter(|entity| is_mutable_level_object(world, *entity))
         .collect();
     if entities.is_empty() {
         return;
     }
-    if would_create_cycle(world, &entities, new_parent) {
+    if let Some(violation) = hierarchy_drop_violation(world, &entities, new_parent) {
+        if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
+            scene_io.set_status(match violation {
+                crate::ui::hierarchy_ops::HierarchyDropViolation::Cycle => {
+                    "Hierarchy change blocked: it would create a cycle".to_string()
+                }
+                crate::ui::hierarchy_ops::HierarchyDropViolation::PrefabBoundary { .. } =>
+                    "Hierarchy change blocked: prefab instance contents are read-only; unpack the instance first"
+                        .to_string(),
+            });
+        }
         return;
     }
 
@@ -628,7 +766,7 @@ pub fn set_editor_visibility_with_history(
     entity: Entity,
     new: EditorVisibility,
 ) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world
@@ -648,7 +786,7 @@ pub fn set_editor_visibility_with_history(
 }
 
 pub fn set_inspector_order_with_history(world: &mut World, entity: Entity, new: InspectorOrder) {
-    if !is_level_object(world, entity) {
+    if !is_mutable_level_object(world, entity) {
         return;
     }
     let old = world.get::<InspectorOrder>(entity).cloned();
@@ -665,7 +803,7 @@ pub fn group_selection_with_history(world: &mut World, entities: &[Entity]) {
     let entities: Vec<Entity> = entities
         .iter()
         .copied()
-        .filter(|entity| is_level_object(world, *entity))
+        .filter(|entity| is_mutable_level_object(world, *entity))
         .collect();
     if entities.is_empty() {
         return;
@@ -686,6 +824,9 @@ pub fn group_selection_with_history(world: &mut World, entities: &[Entity]) {
         collider: None,
         physics: None,
         light: None,
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
@@ -711,7 +852,11 @@ pub fn group_selection_with_history(world: &mut World, entities: &[Entity]) {
 }
 
 pub fn create_empty_child_with_history(world: &mut World, parent: Entity) {
-    if !is_level_object(world, parent) {
+    if !is_level_object(world, parent) || world.get::<HydratedPrefabMember>(parent).is_some() {
+        if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
+            scene_io
+                .set_status("Create child blocked: generated prefab source content is read-only");
+        }
         return;
     }
     let snapshot = EditorEntitySnapshot {
@@ -729,6 +874,9 @@ pub fn create_empty_child_with_history(world: &mut World, parent: Entity) {
         collider: None,
         physics: None,
         light: None,
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
@@ -754,13 +902,268 @@ pub fn create_empty_child_with_history(world: &mut World, parent: Entity) {
 }
 
 pub fn unpack_prefab_instance(world: &mut World, entity: Entity) {
-    if world.get::<PrefabInstance>(entity).is_none() {
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let prefab_ref = world
+        .get::<PrefabRef>(entity)
+        .cloned()
+        .unwrap_or_else(|| PrefabRef::new(instance.source_path.clone()));
+    if world.get::<HydratedPrefabReady>(entity).is_none() {
+        if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
+            scene_io.set_status("Unpack blocked: prefab source is still loading or unavailable");
+        }
         return;
     }
-    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
-        entity_mut.remove::<PrefabInstance>();
+    let linked_actor_kind = world
+        .get::<ActorKind>(entity)
+        .copied()
+        .unwrap_or(ActorKind::PrefabAnchor);
+    if let Err(error) =
+        crate::assets::prefab_overrides::fold_nested_overrides_for_unpack(world, entity)
+    {
+        if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
+            scene_io.set_status(format!("Unpack blocked: {error}"));
+        }
+        return;
     }
-    mark_dirty(world);
+    let unpacked_roots = perform_prefab_unpack(world, entity);
+    let unpacked_parented_to_anchor = unpacked_roots
+        .iter()
+        .map(|root| world.get::<ChildOf>(*root).map(ChildOf::parent) == Some(entity))
+        .collect();
+    let unpacked_snapshots = unpacked_roots
+        .iter()
+        .filter_map(|root| snapshot_entity(world, *root))
+        .collect();
+    push_history(
+        world,
+        EditorCommand::UnpackPrefab {
+            entity,
+            instance,
+            prefab_ref,
+            linked_actor_kind,
+            fully_local: false,
+            linked_local_snapshots: Vec::new(),
+            linked_local_roots: Vec::new(),
+            unpacked_snapshots,
+            unpacked_parented_to_anchor,
+            unpacked_roots,
+        },
+    );
+}
+
+pub fn convert_prefab_completely_to_local(world: &mut World, entity: Entity) {
+    let Some(instance) = world.get::<PrefabInstance>(entity).cloned() else {
+        return;
+    };
+    let prefab_ref = world
+        .get::<PrefabRef>(entity)
+        .cloned()
+        .unwrap_or_else(|| PrefabRef::new(instance.source_path.clone()));
+    let linked_local: Vec<(Entity, EditorEntitySnapshot)> = world
+        .get::<Children>(entity)
+        .map(|children| {
+            children
+                .iter()
+                .filter(|child| world.get::<HydratedPrefabMember>(*child).is_none())
+                .filter_map(|child| snapshot_entity(world, child).map(|snapshot| (child, snapshot)))
+                .collect()
+        })
+        .unwrap_or_default();
+    let linked_local_roots: Vec<Entity> = linked_local.iter().map(|(root, _)| *root).collect();
+    let linked_local_snapshots = linked_local
+        .into_iter()
+        .map(|(_, snapshot)| snapshot)
+        .collect();
+
+    let mut all_instances: Vec<(usize, Entity)> = world
+        .query_filtered::<Entity, With<PrefabInstance>>()
+        .iter(world)
+        .filter_map(|candidate| {
+            prefab_conversion_depth(world, candidate, entity).map(|depth| (depth, candidate))
+        })
+        .collect();
+    all_instances.sort_by_key(|(depth, _)| *depth);
+    if all_instances
+        .iter()
+        .any(|(_, instance_root)| world.get::<HydratedPrefabReady>(*instance_root).is_none())
+    {
+        if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
+            scene_io
+                .set_status("Complete conversion blocked: every nested prefab must finish loading");
+        }
+        return;
+    }
+
+    let linked_actor_kind = world
+        .get::<ActorKind>(entity)
+        .copied()
+        .unwrap_or(ActorKind::PrefabAnchor);
+    let mut candidate_roots = linked_local_roots.clone();
+    for (_, instance_root) in all_instances {
+        candidate_roots.extend(perform_prefab_unpack(world, instance_root));
+    }
+    let candidate_set: HashSet<_> = candidate_roots.iter().copied().collect();
+    candidate_roots.retain(|root| !has_candidate_ancestor(world, *root, &candidate_set));
+    let mut unpacked_roots = Vec::new();
+    let mut unpacked_snapshots = Vec::new();
+    let mut unpacked_parented_to_anchor = Vec::new();
+    for root in candidate_roots {
+        if let Some(snapshot) = snapshot_entity(world, root) {
+            unpacked_parented_to_anchor
+                .push(world.get::<ChildOf>(root).map(ChildOf::parent) == Some(entity));
+            unpacked_roots.push(root);
+            unpacked_snapshots.push(snapshot);
+        }
+    }
+    push_history(
+        world,
+        EditorCommand::UnpackPrefab {
+            entity,
+            instance,
+            prefab_ref,
+            linked_actor_kind,
+            fully_local: true,
+            linked_local_snapshots,
+            linked_local_roots: Vec::new(),
+            unpacked_snapshots,
+            unpacked_parented_to_anchor,
+            unpacked_roots,
+        },
+    );
+}
+
+fn prefab_conversion_depth(world: &World, entity: Entity, root: Entity) -> Option<usize> {
+    let mut current = entity;
+    let mut depth = 0;
+    let mut seen = HashSet::new();
+    while seen.insert(current) {
+        if current == root {
+            return Some(depth);
+        }
+        current = world
+            .get::<HydratedPrefabMember>(current)
+            .map(|owner| owner.instance_root)
+            .or_else(|| world.get::<ChildOf>(current).map(ChildOf::parent))?;
+        depth += 1;
+    }
+    None
+}
+
+fn has_candidate_ancestor(world: &World, entity: Entity, candidates: &HashSet<Entity>) -> bool {
+    let mut current = world.get::<ChildOf>(entity).map(ChildOf::parent);
+    let mut seen = HashSet::new();
+    while let Some(parent) = current {
+        if candidates.contains(&parent) {
+            return true;
+        }
+        if !seen.insert(parent) {
+            break;
+        }
+        current = world.get::<ChildOf>(parent).map(ChildOf::parent);
+    }
+    false
+}
+
+fn perform_prefab_unpack(world: &mut World, entity: Entity) -> Vec<Entity> {
+    let members: Vec<Entity> = world
+        .query::<(Entity, &HydratedPrefabMember)>()
+        .iter(world)
+        .filter_map(|(member, owner)| (owner.instance_root == entity).then_some(member))
+        .collect();
+    let member_set: HashSet<Entity> = members.iter().copied().collect();
+    let roots = members
+        .iter()
+        .copied()
+        .filter(|member| {
+            world
+                .get::<ChildOf>(*member)
+                .map(ChildOf::parent)
+                .is_none_or(|parent| !member_set.contains(&parent))
+        })
+        .collect();
+    for member in members {
+        if let Ok(mut member_mut) = world.get_entity_mut(member) {
+            member_mut.remove::<HydratedPrefabMember>();
+            if member_mut.contains::<LevelObject>() {
+                member_mut.insert(new_actor_id());
+            }
+        }
+    }
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        entity_mut
+            .insert(ActorKind::Empty)
+            .remove::<PrefabInstance>()
+            .remove::<PrefabRef>()
+            .remove::<HydratedPrefabReady>()
+            .remove::<PrefabHydrationBlocked>()
+            .remove::<DynamicWorldRoot>()
+            .remove::<WorldInstance>();
+    }
+    roots
+}
+
+fn despawn_hydrated_prefab_members(world: &mut World, entity: Entity) {
+    let members: Vec<Entity> = world
+        .query::<(Entity, &HydratedPrefabMember)>()
+        .iter(world)
+        .filter_map(|(member, owner)| (owner.instance_root == entity).then_some(member))
+        .collect();
+    let member_set: HashSet<Entity> = members.iter().copied().collect();
+    let roots: Vec<Entity> = members
+        .into_iter()
+        .filter(|member| {
+            world
+                .get::<ChildOf>(*member)
+                .map(ChildOf::parent)
+                .is_none_or(|parent| !member_set.contains(&parent))
+        })
+        .collect();
+    for root in roots {
+        despawn_entity(world, Some(root));
+    }
+}
+
+pub fn capture_prefab_edit_state(world: &World, entity: Entity) -> PrefabEditState {
+    PrefabEditState {
+        instance: world.get::<PrefabInstance>(entity).cloned(),
+        prefab_ref: world.get::<PrefabRef>(entity).cloned(),
+        blocked_reason: world
+            .get::<PrefabHydrationBlocked>(entity)
+            .map(|blocked| blocked.reason.clone()),
+        transform: world.get::<Transform>(entity).copied(),
+        material: world.get::<MaterialDesc>(entity).cloned(),
+    }
+}
+
+pub fn record_prefab_edit_state(world: &mut World, entity: Entity, old: PrefabEditState) {
+    let new = capture_prefab_edit_state(world, entity);
+    if old != new {
+        push_history(world, EditorCommand::SetPrefabState { entity, old, new });
+    }
+}
+
+pub fn record_prefab_source_apply(
+    world: &mut World,
+    entity: Entity,
+    source_path: std::path::PathBuf,
+    before_source: String,
+    after_source: String,
+    old: PrefabEditState,
+) {
+    let new = capture_prefab_edit_state(world, entity);
+    push_history(
+        world,
+        EditorCommand::ApplyPrefabToSource {
+            entity,
+            source_path,
+            before_source,
+            after_source,
+            old,
+            new,
+        },
+    );
 }
 
 pub fn set_transform_with_history(
@@ -769,6 +1172,9 @@ pub fn set_transform_with_history(
     old: Transform,
     new: Transform,
 ) {
+    if !is_mutable_level_object(world, entity) {
+        return;
+    }
     if transform_nearly_eq(&old, &new) {
         return;
     }
@@ -786,6 +1192,9 @@ pub fn set_transform_group_with_history(
     let mut olds = Vec::new();
     let mut news = Vec::new();
     for (entity, old, new) in changes {
+        if !is_mutable_level_object(world, entity) {
+            continue;
+        }
         if transform_nearly_eq(&old, &new) {
             continue;
         }
@@ -814,7 +1223,7 @@ pub fn set_actor_kind_with_history(
     old: ActorKind,
     new: ActorKind,
 ) {
-    if old == new {
+    if !is_mutable_level_object(world, entity) || old == new {
         return;
     }
     push_history(world, EditorCommand::SetActorKind { entity, old, new });
@@ -826,7 +1235,27 @@ pub fn apply_actor_kind(world: &mut World, entity: Entity, kind: ActorKind) {
     }
 }
 
+pub fn set_scene_composition_with_history(world: &mut World, new: SceneComposition) {
+    let old = world.resource::<SceneComposition>().clone();
+    if old == new {
+        return;
+    }
+    world.insert_resource(new.clone());
+    push_history(world, EditorCommand::SetSceneComposition { old, new });
+    world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::ReloadComposition);
+}
+
 pub fn apply_command_undo(world: &mut World) {
+    let candidate = world.resource::<EditorHistory>().undo_stack.last().cloned();
+    if let Some(candidate) = candidate {
+        if let Err(error) = prepare_prefab_source_history(&candidate, true) {
+            world.resource_mut::<EditorHistory>().status = format!("Undo blocked: {error}");
+            world
+                .resource_mut::<SceneIo>()
+                .set_status(format!("Undo blocked: {error}"));
+            return;
+        }
+    }
     let Some(mut command) = world.resource_mut::<EditorHistory>().pop_undo() else {
         return;
     };
@@ -838,6 +1267,16 @@ pub fn apply_command_undo(world: &mut World) {
 }
 
 pub fn apply_command_redo(world: &mut World) {
+    let candidate = world.resource::<EditorHistory>().redo_stack.last().cloned();
+    if let Some(candidate) = candidate {
+        if let Err(error) = prepare_prefab_source_history(&candidate, false) {
+            world.resource_mut::<EditorHistory>().status = format!("Redo blocked: {error}");
+            world
+                .resource_mut::<SceneIo>()
+                .set_status(format!("Redo blocked: {error}"));
+            return;
+        }
+    }
     let Some(mut command) = world.resource_mut::<EditorHistory>().pop_redo() else {
         return;
     };
@@ -848,6 +1287,32 @@ pub fn apply_command_redo(world: &mut World) {
     mark_dirty(world);
 }
 
+fn prepare_prefab_source_history(command: &EditorCommand, undo: bool) -> Result<(), String> {
+    let EditorCommand::ApplyPrefabToSource {
+        source_path,
+        before_source,
+        after_source,
+        ..
+    } = command
+    else {
+        return Ok(());
+    };
+    let (expected, replacement) = if undo {
+        (after_source, before_source)
+    } else {
+        (before_source, after_source)
+    };
+    let current = std::fs::read_to_string(source_path)
+        .map_err(|error| format!("could not read {}: {error}", source_path.display()))?;
+    if &current != expected {
+        return Err(format!(
+            "{} changed outside this history command",
+            source_path.display()
+        ));
+    }
+    crate::scene::recovery::atomic_write(source_path, replacement.as_bytes())
+}
+
 fn undo_command(world: &mut World, command: &mut EditorCommand) {
     match command {
         EditorCommand::Spawn { entity, .. } => {
@@ -884,12 +1349,26 @@ fn undo_command(world: &mut World, command: &mut EditorCommand) {
         EditorCommand::SetMaterial { entity, old, .. } => {
             apply_material(world, *entity, old);
         }
+        EditorCommand::SetMaterialGroup { entities, olds, .. } => {
+            for (entity, old) in entities.iter().zip(olds.iter()) {
+                apply_material(world, *entity, old);
+            }
+        }
         EditorCommand::SetMaterialOverride { entity, old, .. } => {
             apply_material_override(world, *entity, old);
         }
         EditorCommand::SetLight { entity, old, .. } => {
             apply_light(world, *entity, old);
         }
+        EditorCommand::SetAnimationController { entity, old, .. } => {
+            apply_animation_controller(world, *entity, old);
+        }
+        EditorCommand::SetAudioSource { entity, old, .. } => {
+            apply_audio_source(world, *entity, old);
+        }
+        EditorCommand::SetAudioListener { entity, old, .. } => {
+            apply_audio_listener(world, *entity, old);
+        }
         EditorCommand::SetPostProcessVolume { entity, old, .. } => {
             apply_post_process_volume(world, *entity, old);
         }
@@ -969,6 +1448,37 @@ fn undo_command(world: &mut World, command: &mut EditorCommand) {
         EditorCommand::SetInspectorOrder { entity, old, .. } => {
             apply_inspector_order(world, *entity, old);
         }
+        EditorCommand::SetSceneComposition { old, .. } => {
+            world.insert_resource(old.clone());
+            world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::ReloadComposition);
+        }
+        EditorCommand::SetPrefabState { entity, old, .. } => {
+            apply_prefab_edit_state(world, *entity, old);
+        }
+        EditorCommand::ApplyPrefabToSource { entity, old, .. } => {
+            apply_prefab_edit_state(world, *entity, old);
+        }
+        EditorCommand::UnpackPrefab {
+            entity,
+            instance,
+            prefab_ref,
+            linked_actor_kind,
+            linked_local_snapshots,
+            linked_local_roots,
+            unpacked_roots,
+            ..
+        } => {
+            for root in std::mem::take(unpacked_roots) {
+                despawn_entity(world, Some(root));
+            }
+            if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+                entity_mut.insert((*linked_actor_kind, instance.clone(), prefab_ref.clone()));
+            }
+            *linked_local_roots = linked_local_snapshots
+                .iter()
+                .map(|snapshot| spawn_snapshot_with_parent(world, snapshot, Some(*entity)))
+                .collect();
+        }
         EditorCommand::AddComponent { entity, snapshot } => {
             remove_authored_components(world, *entity, snapshot);
         }
@@ -1026,6 +1536,13 @@ fn redo_command(world: &mut World, command: &mut EditorCommand) {
                 entity_mut.insert(new.clone());
             }
         }
+        EditorCommand::SetMaterialGroup { entities, news, .. } => {
+            for (entity, new) in entities.iter().zip(news.iter()) {
+                if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+                    entity_mut.insert(new.clone());
+                }
+            }
+        }
         EditorCommand::SetMaterialOverride { entity, new, .. } => {
             if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
                 entity_mut.insert(new.clone());
@@ -1036,6 +1553,21 @@ fn redo_command(world: &mut World, command: &mut EditorCommand) {
                 entity_mut.insert(new.clone());
             }
         }
+        EditorCommand::SetAnimationController { entity, new, .. } => {
+            if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+                entity_mut.insert(new.clone());
+            }
+        }
+        EditorCommand::SetAudioSource { entity, new, .. } => {
+            if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+                entity_mut.insert(new.clone());
+            }
+        }
+        EditorCommand::SetAudioListener { entity, new, .. } => {
+            if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+                entity_mut.insert(*new);
+            }
+        }
         EditorCommand::SetPostProcessVolume { entity, new, .. } => {
             if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
                 entity_mut.insert(new.clone());
@@ -1128,6 +1660,46 @@ fn redo_command(world: &mut World, command: &mut EditorCommand) {
                 entity_mut.insert(new.clone());
             }
         }
+        EditorCommand::SetSceneComposition { new, .. } => {
+            world.insert_resource(new.clone());
+            world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::ReloadComposition);
+        }
+        EditorCommand::SetPrefabState { entity, new, .. } => {
+            apply_prefab_edit_state(world, *entity, new);
+        }
+        EditorCommand::ApplyPrefabToSource { entity, new, .. } => {
+            apply_prefab_edit_state(world, *entity, new);
+        }
+        EditorCommand::UnpackPrefab {
+            entity,
+            linked_local_roots,
+            unpacked_snapshots,
+            unpacked_parented_to_anchor,
+            unpacked_roots,
+            ..
+        } => {
+            for root in std::mem::take(linked_local_roots) {
+                despawn_entity(world, Some(root));
+            }
+            despawn_hydrated_prefab_members(world, *entity);
+            if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+                entity_mut
+                    .insert(ActorKind::Empty)
+                    .remove::<PrefabInstance>()
+                    .remove::<PrefabRef>()
+                    .remove::<HydratedPrefabReady>()
+                    .remove::<PrefabHydrationBlocked>()
+                    .remove::<DynamicWorldRoot>()
+                    .remove::<WorldInstance>();
+            }
+            *unpacked_roots = unpacked_snapshots
+                .iter()
+                .zip(unpacked_parented_to_anchor.iter())
+                .map(|(snapshot, parented)| {
+                    spawn_snapshot_with_parent(world, snapshot, parented.then_some(*entity))
+                })
+                .collect();
+        }
         EditorCommand::AddComponent { entity, snapshot } => {
             apply_authored_components(world, *entity, snapshot);
         }
@@ -1150,6 +1722,56 @@ fn apply_material(world: &mut World, entity: Entity, material: &Option<MaterialD
     }
 }
 
+fn apply_prefab_edit_state(world: &mut World, entity: Entity, state: &PrefabEditState) {
+    if state.blocked_reason.is_some() {
+        despawn_hydrated_prefab_members(world, entity);
+    }
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        match &state.instance {
+            Some(instance) => {
+                entity_mut.insert(instance.clone());
+            }
+            None => {
+                entity_mut.remove::<PrefabInstance>();
+            }
+        }
+        match &state.prefab_ref {
+            Some(prefab_ref) => {
+                entity_mut.insert(prefab_ref.clone());
+            }
+            None => {
+                entity_mut.remove::<PrefabRef>();
+            }
+        }
+        match &state.blocked_reason {
+            Some(reason) => {
+                entity_mut
+                    .insert(PrefabHydrationBlocked {
+                        reason: reason.clone(),
+                    })
+                    .remove::<HydratedPrefabReady>()
+                    .remove::<DynamicWorldRoot>()
+                    .remove::<WorldInstance>();
+            }
+            None => {
+                entity_mut.remove::<PrefabHydrationBlocked>();
+            }
+        }
+        if let Some(transform) = state.transform {
+            entity_mut.insert(transform);
+        }
+        match &state.material {
+            Some(material) => {
+                entity_mut.insert(material.clone());
+            }
+            None => {
+                entity_mut.remove::<MaterialDesc>();
+            }
+        }
+    }
+    crate::assets::prefab_overrides::apply_stored_overrides(world, entity);
+}
+
 fn apply_material_override(
     world: &mut World,
     entity: Entity,
@@ -1180,6 +1802,49 @@ fn apply_light(world: &mut World, entity: Entity, light: &Option<LightDesc>) {
     }
 }
 
+fn apply_animation_controller(
+    world: &mut World,
+    entity: Entity,
+    controller: &Option<AnimationControllerDesc>,
+) {
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        match controller {
+            Some(value) => {
+                entity_mut.insert(value.clone());
+            }
+            None => {
+                entity_mut.remove::<AnimationControllerDesc>();
+            }
+        }
+    }
+}
+
+fn apply_audio_source(world: &mut World, entity: Entity, source: &Option<AudioSourceDesc>) {
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        match source {
+            Some(value) => {
+                entity_mut.insert(value.clone());
+            }
+            None => {
+                entity_mut.remove::<AudioSourceDesc>();
+            }
+        }
+    }
+}
+
+fn apply_audio_listener(world: &mut World, entity: Entity, listener: &Option<AudioListenerDesc>) {
+    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+        match listener {
+            Some(value) => {
+                entity_mut.insert(*value);
+            }
+            None => {
+                entity_mut.remove::<AudioListenerDesc>();
+            }
+        }
+    }
+}
+
 fn apply_post_process_volume(
     world: &mut World,
     entity: Entity,
@@ -1339,6 +2004,15 @@ fn apply_authored_components(world: &mut World, entity: Entity, snapshot: &Edito
         if let Some(v) = &snapshot.light {
             entity_mut.insert(v.clone());
         }
+        if let Some(v) = &snapshot.animation_controller {
+            entity_mut.insert(v.clone());
+        }
+        if let Some(v) = &snapshot.audio_source {
+            entity_mut.insert(v.clone());
+        }
+        if let Some(v) = snapshot.audio_listener {
+            entity_mut.insert(v);
+        }
         if snapshot.player_spawn {
             entity_mut.insert(PlayerSpawn);
         }
@@ -1370,6 +2044,13 @@ fn apply_authored_components(world: &mut World, entity: Entity, snapshot: &Edito
 }
 
 fn remove_authored_components(world: &mut World, entity: Entity, snapshot: &EditorEntitySnapshot) {
+    let removed_dedicated_audio_kind = matches!(
+        world.get::<ActorKind>(entity).copied(),
+        Some(ActorKind::AudioSource) if snapshot.audio_source.is_some()
+    ) || matches!(
+        world.get::<ActorKind>(entity).copied(),
+        Some(ActorKind::AudioListener) if snapshot.audio_listener.is_some()
+    );
     if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
         if snapshot.primitive.is_some() {
             entity_mut.remove::<Primitive>();
@@ -1398,6 +2079,15 @@ fn remove_authored_components(world: &mut World, entity: Entity, snapshot: &Edit
         if snapshot.light.is_some() {
             entity_mut.remove::<LightDesc>();
         }
+        if snapshot.animation_controller.is_some() {
+            entity_mut.remove::<AnimationControllerDesc>();
+        }
+        if snapshot.audio_source.is_some() {
+            entity_mut.remove::<AudioSourceDesc>();
+        }
+        if snapshot.audio_listener.is_some() {
+            entity_mut.remove::<AudioListenerDesc>();
+        }
         if snapshot.player_spawn {
             entity_mut.remove::<PlayerSpawn>();
         }
@@ -1426,6 +2116,16 @@ fn remove_authored_components(world: &mut World, entity: Entity, snapshot: &Edit
             entity_mut.remove::<ObjectiveMarker>();
         }
     }
+    if removed_dedicated_audio_kind {
+        let fallback = world
+            .get_entity(entity)
+            .ok()
+            .and_then(infer_actor_kind)
+            .unwrap_or(ActorKind::Empty);
+        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.insert(fallback);
+        }
+    }
 }
 
 fn handle_history_hotkeys(world: &mut World) {
@@ -1461,7 +2161,7 @@ fn handle_history_hotkeys(world: &mut World) {
             ui_state
                 .selected_entities
                 .iter()
-                .filter(|entity| is_level_object(world, *entity))
+                .filter(|entity| is_mutable_level_object(world, *entity))
                 .collect()
         })
         .unwrap_or_default();
@@ -1478,7 +2178,7 @@ fn capture_gizmo_transform_edits(world: &mut World) {
         .map(|ui| {
             ui.selected_entities
                 .iter()
-                .filter(|entity| is_level_object(world, *entity))
+                .filter(|entity| is_mutable_level_object(world, *entity))
                 .collect()
         })
         .unwrap_or_default();
@@ -1676,3 +2376,711 @@ pub(crate) fn material_eq(a: &MaterialDesc, b: &MaterialDesc) -> bool {
         && a.parameters == b.parameters
         && a.textures == b.textures
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::operators::test_harness::{assert_undo_redo_round_trip, OperatorInvariantHarness};
+    use crate::operators::{ActiveOperator, OperatorPhase, OperatorStatus};
+
+    fn animation_controller(state_id: &str, crossfade_seconds: f32) -> AnimationControllerDesc {
+        AnimationControllerDesc {
+            skeleton: Some(
+                shared::EditorAssetRef::new("robot-asset", "animation:skeleton:0:robot", "Robot")
+                    .with_source_path("assets/models/robot.glb"),
+            ),
+            states: vec![shared::AnimationStateDesc {
+                id: state_id.to_string(),
+                label: state_id.to_ascii_uppercase(),
+                clip: shared::EditorAssetRef::new(
+                    "robot-asset",
+                    format!("animation:clip:0:{state_id}"),
+                    state_id,
+                )
+                .with_source_path("assets/models/robot.glb"),
+                looping: true,
+                speed: 1.25,
+                range: shared::AnimationPlaybackRange {
+                    start_seconds: 0.1,
+                    end_seconds: Some(1.8),
+                },
+            }],
+            default_state: state_id.to_string(),
+            default_crossfade_seconds: crossfade_seconds,
+        }
+    }
+
+    #[test]
+    fn animation_controller_history_round_trips_and_marks_scene_dirty() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let old = animation_controller("idle", 0.15);
+        let new = animation_controller("run", 0.3);
+        let entity = world
+            .spawn((
+                LevelObject,
+                ActorKind::ImportedModel,
+                Transform::IDENTITY,
+                old.clone(),
+            ))
+            .id();
+
+        set_animation_controller_with_history(&mut world, entity, new.clone());
+
+        assert_eq!(world.get::<AnimationControllerDesc>(entity), Some(&new));
+        assert_eq!(world.resource::<EditorHistory>().undo_depth(), 1);
+        assert!(world.resource::<SceneIo>().dirty);
+
+        apply_command_undo(&mut world);
+        assert_eq!(world.get::<AnimationControllerDesc>(entity), Some(&old));
+
+        apply_command_redo(&mut world);
+        assert_eq!(world.get::<AnimationControllerDesc>(entity), Some(&new));
+    }
+
+    #[test]
+    fn undoing_a_new_animation_controller_removes_the_component() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let controller = animation_controller("idle", 0.2);
+        let entity = world
+            .spawn((LevelObject, ActorKind::ImportedModel, Transform::IDENTITY))
+            .id();
+
+        set_animation_controller_with_history(&mut world, entity, controller.clone());
+        apply_command_undo(&mut world);
+        assert!(world.get::<AnimationControllerDesc>(entity).is_none());
+
+        apply_command_redo(&mut world);
+        assert_eq!(
+            world.get::<AnimationControllerDesc>(entity),
+            Some(&controller)
+        );
+    }
+
+    #[test]
+    fn animation_controller_survives_snapshot_respawn() {
+        let mut world = World::new();
+        let controller = animation_controller("idle", 0.2);
+        let source = world
+            .spawn((
+                LevelObject,
+                ActorKind::ImportedModel,
+                Name::new("Animated Robot"),
+                Transform::from_xyz(1.0, 2.0, 3.0),
+                controller.clone(),
+            ))
+            .id();
+        let snapshot = snapshot_entity(&world, source).expect("level object is snapshotable");
+
+        world.entity_mut(source).despawn();
+        let respawned = spawn_snapshot(&mut world, &snapshot);
+
+        assert_eq!(
+            world.get::<AnimationControllerDesc>(respawned),
+            Some(&controller)
+        );
+        assert_eq!(
+            world.get::<Name>(respawned).map(Name::as_str),
+            Some("Animated Robot")
+        );
+    }
+
+    #[test]
+    fn removing_dedicated_audio_components_repairs_and_restores_actor_kind() {
+        let mut world = World::new();
+        let source = world
+            .spawn((
+                LevelObject,
+                ActorKind::AudioSource,
+                Transform::IDENTITY,
+                AudioSourceDesc::default(),
+            ))
+            .id();
+        let source_snapshot = snapshot_entity(&world, source).unwrap();
+
+        remove_authored_components(&mut world, source, &source_snapshot);
+        assert!(world.get::<AudioSourceDesc>(source).is_none());
+        assert_eq!(world.get::<ActorKind>(source), Some(&ActorKind::Empty));
+
+        apply_authored_components(&mut world, source, &source_snapshot);
+        assert!(world.get::<AudioSourceDesc>(source).is_some());
+        assert_eq!(
+            world.get::<ActorKind>(source),
+            Some(&ActorKind::AudioSource)
+        );
+
+        let listener = world
+            .spawn((
+                LevelObject,
+                ActorKind::AudioListener,
+                Transform::IDENTITY,
+                AudioListenerDesc::default(),
+            ))
+            .id();
+        let listener_snapshot = snapshot_entity(&world, listener).unwrap();
+
+        remove_authored_components(&mut world, listener, &listener_snapshot);
+        assert!(world.get::<AudioListenerDesc>(listener).is_none());
+        assert_eq!(world.get::<ActorKind>(listener), Some(&ActorKind::Empty));
+
+        apply_authored_components(&mut world, listener, &listener_snapshot);
+        assert!(world.get::<AudioListenerDesc>(listener).is_some());
+        assert_eq!(
+            world.get::<ActorKind>(listener),
+            Some(&ActorKind::AudioListener)
+        );
+    }
+
+    #[test]
+    fn continuous_multi_transform_finalizes_as_one_undo_group() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let first = world.spawn((LevelObject, Transform::default())).id();
+        let second = world
+            .spawn((
+                LevelObject,
+                Transform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            ))
+            .id();
+        let initial = vec![Vec3::ZERO, Vec3::new(2.0, 0.0, 0.0)];
+        let committed = vec![Vec3::Z, Vec3::new(2.0, 0.0, 1.0)];
+        let harness = OperatorInvariantHarness::capture(&mut world);
+
+        set_transform_group_with_history(
+            &mut world,
+            [
+                (
+                    first,
+                    Transform::default(),
+                    Transform::from_translation(committed[0]),
+                ),
+                (
+                    second,
+                    Transform::from_translation(initial[1]),
+                    Transform::from_translation(committed[1]),
+                ),
+            ],
+        );
+        world.resource_mut::<ActiveOperator>().status = Some(OperatorStatus {
+            id: "transform.gizmo".to_string(),
+            label: "Transform Gizmo".to_string(),
+            phase: OperatorPhase::Committed,
+            hint: "Committed multi-selection drag".to_string(),
+            warnings: Vec::new(),
+        });
+
+        harness.assert_committed(&mut world, 1, 0);
+        assert_undo_redo_round_trip(&mut world, initial, committed, |world| {
+            [first, second]
+                .into_iter()
+                .map(|entity| world.get::<Transform>(entity).unwrap().translation)
+                .collect::<Vec<_>>()
+        });
+    }
+
+    #[test]
+    fn unpack_prefab_is_one_undoable_history_command() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let instance = PrefabInstance::new("asset", "assets/prefabs/crate.scn.ron");
+        let root = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                instance.clone(),
+                PrefabRef::new(instance.source_path.clone()),
+                HydratedPrefabReady,
+            ))
+            .id();
+        let generated = world
+            .spawn((
+                LevelObject,
+                ActorId::new("generated-child"),
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+
+        unpack_prefab_instance(&mut world, root);
+
+        assert_eq!(world.resource::<EditorHistory>().undo_depth(), 1);
+        assert!(world.get::<PrefabInstance>(root).is_none());
+        assert!(world.get::<PrefabRef>(root).is_none());
+        assert_eq!(world.get::<ActorKind>(root), Some(&ActorKind::Empty));
+        assert!(world.get::<HydratedPrefabMember>(generated).is_none());
+        let unpacked_actor_id = world.get::<ActorId>(generated).unwrap().0.clone();
+        assert_ne!(unpacked_actor_id, "generated-child");
+
+        apply_command_undo(&mut world);
+        assert_eq!(world.get::<PrefabInstance>(root), Some(&instance));
+        assert!(world.get::<PrefabRef>(root).is_some());
+        assert_eq!(world.get::<ActorKind>(root), Some(&ActorKind::PrefabAnchor));
+        assert!(world.get_entity(generated).is_err());
+
+        world
+            .entity_mut(root)
+            .insert(PrefabHydrationBlocked {
+                reason: "source removed after undo".to_string(),
+            })
+            .remove::<PrefabRef>();
+        apply_command_redo(&mut world);
+        assert!(world.get::<PrefabInstance>(root).is_none());
+        assert!(world.get::<PrefabRef>(root).is_none());
+        assert!(world.get::<PrefabHydrationBlocked>(root).is_none());
+        assert_eq!(world.get::<ActorKind>(root), Some(&ActorKind::Empty));
+        assert!(!world.resource::<EditorHistory>().can_redo());
+        let restored = world
+            .query::<(Entity, &ActorId)>()
+            .iter(&world)
+            .find_map(|(entity, actor_id)| (actor_id.0 == unpacked_actor_id).then_some(entity))
+            .expect("redo should restore the committed local actor without source readiness");
+        assert_eq!(
+            world.get::<ChildOf>(restored).map(ChildOf::parent),
+            Some(root)
+        );
+        assert_eq!(world.get::<ActorId>(restored).unwrap().0, unpacked_actor_id);
+    }
+
+    #[test]
+    fn unpack_redo_uses_committed_snapshot_instead_of_mutated_source() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let instance = PrefabInstance::new("asset", "assets/prefabs/crate.scn.ron");
+        let root = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                instance.clone(),
+                PrefabRef::new(instance.source_path.clone()),
+                HydratedPrefabReady,
+            ))
+            .id();
+        let generated = world
+            .spawn((
+                LevelObject,
+                ActorKind::StaticMesh,
+                ActorId::new("source-child"),
+                Name::new("Committed Source Actor"),
+                Transform::from_xyz(1.0, 2.0, 3.0),
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+
+        unpack_prefab_instance(&mut world, root);
+        let committed_actor_id = world.get::<ActorId>(generated).unwrap().0.clone();
+        apply_command_undo(&mut world);
+
+        let mutated_source = world
+            .spawn((
+                LevelObject,
+                ActorKind::Light,
+                ActorId::new("source-child"),
+                Name::new("Mutated Source Actor"),
+                Transform::from_xyz(90.0, 80.0, 70.0),
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        world.entity_mut(root).insert(HydratedPrefabReady);
+
+        apply_command_redo(&mut world);
+
+        assert!(world.get_entity(mutated_source).is_err());
+        let restored = world
+            .query::<(Entity, &ActorId)>()
+            .iter(&world)
+            .find_map(|(entity, actor_id)| (actor_id.0 == committed_actor_id).then_some(entity))
+            .expect("redo should recreate the originally committed local actor");
+        assert_eq!(
+            world.get::<Name>(restored).map(Name::as_str),
+            Some("Committed Source Actor")
+        );
+        assert_eq!(
+            world.get::<Transform>(restored).unwrap().translation,
+            Vec3::new(1.0, 2.0, 3.0)
+        );
+        assert_eq!(
+            world.get::<ActorKind>(restored),
+            Some(&ActorKind::StaticMesh)
+        );
+        assert!(world.get::<HydratedPrefabMember>(restored).is_none());
+    }
+
+    #[test]
+    fn unpack_redo_preserves_structurally_unparented_roots() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let root = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                PrefabInstance::new("asset", "assets/prefabs/test.scn.ron"),
+                PrefabRef::new("assets/prefabs/test.scn.ron"),
+                HydratedPrefabReady,
+            ))
+            .id();
+        let generated = world
+            .spawn((
+                LevelObject,
+                ActorId::new("unparented-source-child"),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+
+        unpack_prefab_instance(&mut world, root);
+        let local_actor_id = world.get::<ActorId>(generated).unwrap().0.clone();
+        assert!(world.get::<ChildOf>(generated).is_none());
+
+        apply_command_undo(&mut world);
+        apply_command_redo(&mut world);
+
+        let restored = world
+            .query::<(Entity, &ActorId)>()
+            .iter(&world)
+            .find_map(|(entity, actor_id)| (actor_id.0 == local_actor_id).then_some(entity))
+            .expect("redo should restore the committed unparented root");
+        assert!(world.get::<ChildOf>(restored).is_none());
+    }
+
+    #[test]
+    fn unpack_layer_preserves_nested_prefab_links() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let base_material = MaterialDesc::default();
+        let mut overridden_material = base_material.clone();
+        overridden_material.roughness = 0.21;
+        let mut outer_instance = PrefabInstance::new("outer", "assets/prefabs/outer.scn.ron");
+        outer_instance.overrides_ron = shared::encode_prefab_overrides(&shared::PrefabOverrides {
+            properties: vec![shared::PrefabPropertyOverride {
+                target: shared::PrefabActorPath {
+                    instance_chain: vec!["nested-anchor".to_string()],
+                    actor_id: "nested-child".to_string(),
+                },
+                component_type: std::any::type_name::<MaterialDesc>().to_string(),
+                property_path: "roughness".to_string(),
+                base_component_ron: ron::to_string(&base_material).unwrap(),
+                value_component_ron: ron::to_string(&overridden_material).unwrap(),
+            }],
+            ..default()
+        })
+        .unwrap();
+        let root = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                outer_instance,
+                PrefabRef::new("assets/prefabs/outer.scn.ron"),
+                HydratedPrefabReady,
+            ))
+            .id();
+        let nested = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                ActorId::new("nested-anchor"),
+                PrefabInstance::new("nested", "assets/prefabs/nested.scn.ron"),
+                PrefabRef::new("assets/prefabs/nested.scn.ron"),
+                HydratedPrefabReady,
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        let nested_child = world
+            .spawn((
+                LevelObject,
+                ActorId::new("nested-child"),
+                overridden_material,
+                ChildOf(nested),
+                HydratedPrefabMember {
+                    instance_root: nested,
+                },
+            ))
+            .id();
+
+        unpack_prefab_instance(&mut world, root);
+
+        assert!(world.get::<PrefabInstance>(root).is_none());
+        assert!(world.get::<PrefabInstance>(nested).is_some());
+        assert!(world.get::<HydratedPrefabMember>(nested).is_none());
+        assert_eq!(
+            world
+                .get::<HydratedPrefabMember>(nested_child)
+                .map(|owner| owner.instance_root),
+            Some(nested)
+        );
+        let nested_overrides =
+            shared::decode_prefab_overrides(world.get::<PrefabInstance>(nested).unwrap()).unwrap();
+        assert_eq!(nested_overrides.properties.len(), 1);
+        assert!(nested_overrides.properties[0]
+            .target
+            .instance_chain
+            .is_empty());
+        assert_eq!(
+            ron::from_str::<MaterialDesc>(&nested_overrides.properties[0].value_component_ron)
+                .unwrap()
+                .roughness,
+            0.21
+        );
+    }
+
+    #[test]
+    fn complete_prefab_conversion_is_recursive_unique_and_undoable() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let outer_instance = PrefabInstance::new("outer", "assets/prefabs/outer.scn.ron");
+        let root = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                outer_instance.clone(),
+                PrefabRef::new(outer_instance.source_path.clone()),
+                HydratedPrefabReady,
+            ))
+            .id();
+        world.spawn((
+            LevelObject,
+            ActorId::new("repeated-source-id"),
+            Name::new("Outer Child"),
+            ChildOf(root),
+            HydratedPrefabMember {
+                instance_root: root,
+            },
+        ));
+        let nested = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                ActorId::new("nested-anchor"),
+                Name::new("Nested Anchor"),
+                PrefabInstance::new("nested", "assets/prefabs/nested.scn.ron"),
+                PrefabRef::new("assets/prefabs/nested.scn.ron"),
+                HydratedPrefabReady,
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        world.spawn((
+            LevelObject,
+            ActorId::new("repeated-source-id"),
+            Name::new("Nested Child"),
+            ChildOf(nested),
+            HydratedPrefabMember {
+                instance_root: nested,
+            },
+        ));
+        let local_nested = world
+            .spawn((
+                LevelObject,
+                ActorKind::PrefabAnchor,
+                ActorId::new("authored-local-anchor"),
+                Name::new("Authored Local Nested"),
+                PrefabInstance::new("local-nested", "assets/prefabs/local.scn.ron"),
+                PrefabRef::new("assets/prefabs/local.scn.ron"),
+                HydratedPrefabReady,
+                ChildOf(root),
+            ))
+            .id();
+        world.spawn((
+            LevelObject,
+            ActorId::new("repeated-source-id"),
+            Name::new("Authored Local Child"),
+            ChildOf(local_nested),
+            HydratedPrefabMember {
+                instance_root: local_nested,
+            },
+        ));
+
+        convert_prefab_completely_to_local(&mut world, root);
+
+        let mut prefab_instances = world.query::<&PrefabInstance>();
+        assert_eq!(prefab_instances.iter(&world).count(), 0);
+        let mut generated_members = world.query::<&HydratedPrefabMember>();
+        assert_eq!(generated_members.iter(&world).count(), 0);
+        let ids: Vec<String> = world
+            .query_filtered::<&ActorId, With<LevelObject>>()
+            .iter(&world)
+            .map(|actor_id| actor_id.0.clone())
+            .collect();
+        let unique: HashSet<_> = ids.iter().collect();
+        assert_eq!(ids.len(), unique.len());
+        assert_eq!(world.resource::<EditorHistory>().undo_depth(), 1);
+
+        apply_command_undo(&mut world);
+        assert_eq!(world.get::<PrefabInstance>(root), Some(&outer_instance));
+        let mut prefab_instances = world.query::<(Entity, &PrefabInstance)>();
+        let restored_instances: Vec<_> = prefab_instances.iter(&world).collect();
+        assert_eq!(restored_instances.len(), 2);
+        let restored_local = world
+            .query::<(Entity, &Name, &PrefabInstance)>()
+            .iter(&world)
+            .find_map(|(entity, name, _)| {
+                (name.as_str() == "Authored Local Nested").then_some(entity)
+            })
+            .expect("undo should restore authored local nested links");
+        assert_eq!(
+            world.get::<ChildOf>(restored_local).map(ChildOf::parent),
+            Some(root)
+        );
+
+        apply_command_redo(&mut world);
+        assert!(world.get::<PrefabInstance>(root).is_none());
+        let mut prefab_instances = world.query::<&PrefabInstance>();
+        assert_eq!(prefab_instances.iter(&world).count(), 0);
+        let ids: Vec<String> = world
+            .query_filtered::<&ActorId, With<LevelObject>>()
+            .iter(&world)
+            .map(|actor_id| actor_id.0.clone())
+            .collect();
+        let unique: HashSet<_> = ids.iter().collect();
+        assert_eq!(ids.len(), unique.len());
+    }
+
+    #[test]
+    fn unpack_waits_for_source_readiness() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let root = world
+            .spawn((
+                LevelObject,
+                PrefabInstance::new("asset", "assets/prefabs/missing.scn.ron"),
+                PrefabRef::new("assets/prefabs/missing.scn.ron"),
+            ))
+            .id();
+
+        unpack_prefab_instance(&mut world, root);
+
+        assert!(world.get::<PrefabInstance>(root).is_some());
+        assert_eq!(world.resource::<EditorHistory>().undo_depth(), 0);
+        assert!(world.resource::<SceneIo>().status.contains("still loading"));
+    }
+
+    #[test]
+    fn duplicate_remaps_actor_ids_and_excludes_generated_members() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<SelectedEntity>();
+        let root = world
+            .spawn((
+                LevelObject,
+                ActorId::new("root"),
+                PrefabInstance::new("asset", "assets/prefabs/test.scn.ron"),
+            ))
+            .id();
+        world.spawn((
+            LevelObject,
+            ActorId::new("generated"),
+            ChildOf(root),
+            HydratedPrefabMember {
+                instance_root: root,
+            },
+        ));
+        world.spawn((LevelObject, ActorId::new("local"), ChildOf(root)));
+
+        duplicate_entities_with_history(&mut world, &[root]);
+
+        let ids: Vec<String> = world
+            .query_filtered::<&ActorId, With<LevelObject>>()
+            .iter(&world)
+            .map(|id| id.0.clone())
+            .collect();
+        let unique: HashSet<_> = ids.iter().collect();
+        assert_eq!(ids.len(), 5, "generated source content must not be copied");
+        assert_eq!(unique.len(), ids.len(), "duplicated actors need fresh IDs");
+    }
+
+    #[test]
+    fn linked_members_reject_direct_history_mutations() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<SelectedEntity>();
+        let root = world.spawn(LevelObject).id();
+        let member = world
+            .spawn((
+                LevelObject,
+                Name::new("Source Actor"),
+                Transform::default(),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+
+        rename_entity_with_history(&mut world, member, "Mutated".to_string());
+        set_transform_with_history(
+            &mut world,
+            member,
+            Transform::default(),
+            Transform::from_xyz(9.0, 0.0, 0.0),
+        );
+        set_editor_visibility_with_history(&mut world, member, EditorVisibility { visible: false });
+        delete_entities_with_history(&mut world, &[member]);
+
+        assert_eq!(world.get::<Name>(member).unwrap().as_str(), "Source Actor");
+        assert_eq!(
+            world.get::<Transform>(member).unwrap(),
+            &Transform::default()
+        );
+        assert!(world.get_entity(member).is_ok());
+        assert_eq!(world.resource::<EditorHistory>().undo_depth(), 0);
+    }
+
+    #[test]
+    fn undoing_prefab_relink_restores_broken_hydration_guard() {
+        let mut world = World::new();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let broken = PrefabInstance::new("broken", "assets/prefabs/missing.scn.ron");
+        let root = world
+            .spawn((
+                LevelObject,
+                broken.clone(),
+                PrefabHydrationBlocked {
+                    reason: "missing prefab source".to_string(),
+                },
+            ))
+            .id();
+        let old = capture_prefab_edit_state(&world, root);
+        let valid = PrefabInstance::new("valid", "assets/prefabs/valid.scn.ron");
+        world
+            .entity_mut(root)
+            .remove::<PrefabHydrationBlocked>()
+            .insert((valid.clone(), PrefabRef::new(valid.source_path.clone())));
+        record_prefab_edit_state(&mut world, root, old);
+
+        apply_command_undo(&mut world);
+
+        assert_eq!(world.get::<PrefabInstance>(root), Some(&broken));
+        assert!(world.get::<PrefabRef>(root).is_none());
+        assert!(world
+            .get::<PrefabHydrationBlocked>(root)
+            .is_some_and(|blocked| blocked.reason == "missing prefab source"));
+        assert!(world.get::<DynamicWorldRoot>(root).is_none());
+        assert!(world.get::<WorldInstance>(root).is_none());
+    }
+}
diff --git a/crates/editor/src/lib.rs b/crates/editor/src/lib.rs
index b0763da..3470647 100644
--- a/crates/editor/src/lib.rs
+++ b/crates/editor/src/lib.rs
@@ -22,7 +22,10 @@ pub use ext::extensibility;
 pub use ext::hot_reload;
 pub use play::net_editor;
 pub use play::state;
+pub use project::diagnostics_bundle;
+pub use project::launcher;
 pub use project::project_io;
+pub use project::session;
 pub use project::settings_ui;
 pub use scene::scene_io;
 pub use scene::scene_schema;
@@ -43,7 +46,8 @@ use bevy::app::PluginGroupBuilder;
 use bevy::prelude::*;
 use bevy_egui::EguiPlugin;
 use game::{
-    launch, GameInputEnabled, GameInputFocused, GamePlugin, GameRenderBootstrap, SimEnabled,
+    launch, GameInputEnabled, GameInputFocused, GamePlugin, GameRenderBootstrap,
+    GameSceneBootstrap, SimEnabled,
 };
 use transform_gizmo_bevy::prelude::TransformGizmoPlugin;
 
@@ -58,6 +62,7 @@ use gizmos::EditorGizmoPlugin;
 use history::EditorHistoryPlugin;
 use infra::EditorInfraPlugin;
 use operators::OperatorPlugin;
+use play::audio_preview::AudioPreviewPlugin;
 use play::PlaySessionPlugin;
 use project_io::ProjectIoPlugin;
 use render_view::RenderViewPlugin;
@@ -65,6 +70,7 @@ use scene_io::SceneIoPlugin;
 use scene_view::SceneViewPlugin;
 use selection::EditorSelectionPlugin;
 use selection_outline::SelectionOutlinePlugin;
+use session::EditorSessionPlugin;
 use settings_ui::SettingsUiPlugin;
 use state::EditorStatePlugin;
 use ui::EditorUiPlugin;
@@ -97,6 +103,7 @@ impl PluginGroup for EditorPluginGroup {
             .add(BrushEditPlugin)
             .add(BrushToolPlugin)
             .add(EditorCameraPlugin)
+            .add(AudioPreviewPlugin)
             .add(ActorIconsPlugin)
             .add(EditorSelectionPlugin)
             .add(SelectionOutlinePlugin)
@@ -105,6 +112,7 @@ impl PluginGroup for EditorPluginGroup {
             .add(EditorHistoryPlugin)
             .add(SceneIoPlugin)
             .add(EditorUiPlugin)
+            .add(EditorSessionPlugin)
             .add(brp::BrpPlugin);
         #[cfg(feature = "hot-reload")]
         let group = group.add(hot_reload::HotReloadPlugin);
@@ -121,6 +129,9 @@ pub fn configure_editor_app(app: &mut App) {
         .insert_resource(GameRenderBootstrap {
             defer_player_camera_fx: true,
         })
+        .insert_resource(GameSceneBootstrap {
+            defer_default_level: true,
+        })
         .add_plugins(GamePlugin)
         .add_plugins(MeshPickingPlugin)
         .add_plugins(TransformGizmoPlugin)
diff --git a/crates/editor/src/operators.rs b/crates/editor/src/operators.rs
index 4f033cb..c5ed841 100644
--- a/crates/editor/src/operators.rs
+++ b/crates/editor/src/operators.rs
@@ -4,6 +4,9 @@ use bevy::prelude::*;
 
 use crate::history::EditorHistory;
 
+#[cfg(test)]
+pub(crate) mod test_harness;
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum OperatorPhase {
     Idle,
@@ -227,12 +230,19 @@ fn set_operator_status(world: &mut World, status: OperatorStatus) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::history::EditorHistory;
+    use crate::operators::test_harness::OperatorInvariantHarness;
+    use crate::scene_io::SceneIo;
 
     #[derive(Resource, Default)]
     struct Counter(i32);
 
+    #[derive(Component)]
+    struct PreviewHelper;
+
     struct CounterOperator {
         before: i32,
+        helper: Option<Entity>,
     }
 
     impl EditorOperator for CounterOperator {
@@ -246,6 +256,7 @@ mod tests {
 
         fn begin(&mut self, world: &mut World) -> Result<(), String> {
             self.before = world.resource::<Counter>().0;
+            self.helper = Some(world.spawn(PreviewHelper).id());
             Ok(())
         }
 
@@ -254,34 +265,50 @@ mod tests {
             Ok(())
         }
 
-        fn commit(&mut self, _world: &mut World) -> Result<(), String> {
+        fn commit(&mut self, world: &mut World) -> Result<(), String> {
+            self.remove_helper(world);
             Ok(())
         }
 
         fn cancel(&mut self, world: &mut World) {
             world.resource_mut::<Counter>().0 = self.before;
+            self.remove_helper(world);
         }
     }
 
+    impl CounterOperator {
+        fn remove_helper(&mut self, world: &mut World) {
+            if let Some(helper) = self.helper.take() {
+                if let Ok(entity) = world.get_entity_mut(helper) {
+                    entity.despawn();
+                }
+            }
+        }
+    }
+
+    fn test_world() -> World {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<Counter>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world
+    }
+
     #[test]
     fn operator_commit_keeps_previewed_change() {
-        let mut world = World::new();
-        world.init_resource::<ActiveOperator>();
-        world.init_resource::<Counter>();
+        let mut world = test_world();
+        let harness = OperatorInvariantHarness::capture(&mut world);
 
-        let mut operator = CounterOperator { before: 0 };
+        let mut operator = CounterOperator {
+            before: 0,
+            helper: None,
+        };
 
         assert!(run_operator(&mut world, &mut operator));
         assert_eq!(world.resource::<Counter>().0, 1);
-        assert_eq!(
-            world
-                .resource::<ActiveOperator>()
-                .status
-                .as_ref()
-                .unwrap()
-                .phase,
-            OperatorPhase::Committed
-        );
+        harness.assert_committed(&mut world, 0, 0);
+        harness.assert_no_helpers::<PreviewHelper>(&mut world);
     }
 
     #[test]
@@ -314,22 +341,38 @@ mod tests {
             }
         }
 
-        let mut world = World::new();
-        world.init_resource::<ActiveOperator>();
-        world.init_resource::<Counter>();
+        let mut world = test_world();
+        let harness = OperatorInvariantHarness::capture(&mut world);
 
-        let mut operator = FailingCounterOperator(CounterOperator { before: 0 });
+        let mut operator = FailingCounterOperator(CounterOperator {
+            before: 0,
+            helper: None,
+        });
 
         assert!(!run_operator(&mut world, &mut operator));
         assert_eq!(world.resource::<Counter>().0, 0);
-        assert_eq!(
-            world
-                .resource::<ActiveOperator>()
-                .status
-                .as_ref()
-                .unwrap()
-                .phase,
-            OperatorPhase::Canceled
+        harness.assert_canceled(&mut world);
+        harness.assert_no_helpers::<PreviewHelper>(&mut world);
+    }
+
+    #[test]
+    fn blocked_operator_never_begins_or_mutates_world() {
+        let mut world = test_world();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+
+        let result = run_immediate_operator(
+            &mut world,
+            "test.blocked",
+            "Blocked Operator",
+            OperatorAvailability::Disabled("fixture unavailable".to_string()),
+            |world| {
+                world.resource_mut::<Counter>().0 += 1;
+                Ok(())
+            },
         );
+
+        assert!(!result);
+        assert_eq!(world.resource::<Counter>().0, 0);
+        harness.assert_blocked(&mut world);
     }
 }
diff --git a/crates/editor/src/operators/test_harness.rs b/crates/editor/src/operators/test_harness.rs
new file mode 100644
index 0000000..ec63567
--- /dev/null
+++ b/crates/editor/src/operators/test_harness.rs
@@ -0,0 +1,136 @@
+//! Reusable invariant assertions for modal tools and editor operators.
+
+use std::fmt::Debug;
+
+use bevy::prelude::*;
+use shared::LevelObject;
+
+use crate::history::{apply_command_redo, apply_command_undo, EditorHistory};
+use crate::operators::{ActiveOperator, OperatorPhase};
+use crate::scene_io::SceneIo;
+
+#[derive(Debug)]
+pub(crate) struct OperatorInvariantHarness {
+    undo_depth: usize,
+    dirty: bool,
+    authored_count: usize,
+}
+
+impl OperatorInvariantHarness {
+    pub(crate) fn capture(world: &mut World) -> Self {
+        Self {
+            undo_depth: world
+                .get_resource::<EditorHistory>()
+                .map(EditorHistory::undo_depth)
+                .unwrap_or_default(),
+            dirty: world
+                .get_resource::<SceneIo>()
+                .is_some_and(|scene_io| scene_io.dirty),
+            authored_count: authored_count(world),
+        }
+    }
+
+    pub(crate) fn assert_committed(
+        &self,
+        world: &mut World,
+        undo_delta: usize,
+        authored_delta: isize,
+    ) {
+        self.assert_phase(world, OperatorPhase::Committed);
+        assert_eq!(
+            world.resource::<EditorHistory>().undo_depth(),
+            self.undo_depth + undo_delta,
+            "committed operator must create the expected number of undo groups"
+        );
+        if undo_delta > 0 {
+            assert!(
+                world.resource::<SceneIo>().dirty,
+                "a committed authored mutation must mark the scene dirty"
+            );
+        }
+        assert_eq!(
+            authored_count(world) as isize,
+            self.authored_count as isize + authored_delta,
+            "committed operator changed an unexpected number of authored entities"
+        );
+    }
+
+    pub(crate) fn assert_canceled(&self, world: &mut World) {
+        self.assert_phase(world, OperatorPhase::Canceled);
+        assert_eq!(
+            world.resource::<EditorHistory>().undo_depth(),
+            self.undo_depth,
+            "canceled operator must not create undo history"
+        );
+        assert_eq!(
+            world.resource::<SceneIo>().dirty,
+            self.dirty,
+            "canceled operator must preserve the prior dirty state"
+        );
+        assert_eq!(
+            authored_count(world),
+            self.authored_count,
+            "canceled operator must restore authored entity state"
+        );
+    }
+
+    pub(crate) fn assert_blocked(&self, world: &mut World) {
+        self.assert_phase(world, OperatorPhase::Blocked);
+        assert_eq!(
+            world.resource::<EditorHistory>().undo_depth(),
+            self.undo_depth
+        );
+        assert_eq!(world.resource::<SceneIo>().dirty, self.dirty);
+        assert_eq!(authored_count(world), self.authored_count);
+    }
+
+    pub(crate) fn assert_no_helpers<T: Component>(&self, world: &mut World) {
+        let mut query = world.query_filtered::<Entity, With<T>>();
+        assert_eq!(
+            query.iter(world).count(),
+            0,
+            "operator left preview/helper entities behind"
+        );
+    }
+
+    fn assert_phase(&self, world: &World, expected: OperatorPhase) {
+        let phase = world
+            .resource::<ActiveOperator>()
+            .status
+            .as_ref()
+            .map(|status| status.phase.clone());
+        assert_eq!(phase, Some(expected), "operator reported the wrong phase");
+    }
+}
+
+pub(crate) fn assert_undo_redo_round_trip<T>(
+    world: &mut World,
+    initial: T,
+    committed: T,
+    mut read: impl FnMut(&mut World) -> T,
+) where
+    T: Debug + PartialEq,
+{
+    assert_eq!(
+        read(world),
+        committed,
+        "commit state did not match expectation"
+    );
+    apply_command_undo(world);
+    assert_eq!(
+        read(world),
+        initial,
+        "undo did not restore the initial state"
+    );
+    apply_command_redo(world);
+    assert_eq!(
+        read(world),
+        committed,
+        "redo did not restore the committed state"
+    );
+}
+
+fn authored_count(world: &mut World) -> usize {
+    let mut query = world.query_filtered::<Entity, With<LevelObject>>();
+    query.iter(world).count()
+}
diff --git a/crates/editor/src/play/audio_preview.rs b/crates/editor/src/play/audio_preview.rs
new file mode 100644
index 0000000..593ac10
--- /dev/null
+++ b/crates/editor/src/play/audio_preview.rs
@@ -0,0 +1,468 @@
+//! Transient, non-dirty audio audition owned by the editor.
+
+use bevy::asset::LoadState;
+use bevy::audio::{
+    AudioPlayer, AudioSink, AudioSinkPlayback, AudioSource, PlaybackMode, PlaybackSettings,
+    SpatialAudioSink, SpatialListener, SpatialScale, Volume,
+};
+use bevy::prelude::*;
+use settings::AUDIO_BUS_SFX_ID;
+use shared::{asset_server_path, AudioAttenuationDesc, AudioSourceDesc};
+
+use crate::assets::{EditorAsset, EditorAssetKind};
+use crate::camera::EditorCamera;
+use crate::infra::EditorOnly;
+use crate::state::EditorMode;
+
+#[derive(Resource, Debug, Clone, Default)]
+pub struct AudioPreviewState {
+    pub voices: Vec<Entity>,
+    pub source: Option<Entity>,
+    pub clip_path: Option<String>,
+    pub status: String,
+    clip_handle: Option<Handle<AudioSource>>,
+    listener: Option<Entity>,
+}
+
+#[derive(Component, Debug, Clone)]
+struct AudioPreviewVoice {
+    source: Option<Entity>,
+    bus: String,
+    source_gain_db: f32,
+    mix_weight: f32,
+    spatial: bool,
+    attenuation: AudioAttenuationDesc,
+}
+
+#[derive(Component, Debug, Clone, Copy)]
+struct EditorAudioPreviewListener;
+
+pub struct AudioPreviewPlugin;
+
+impl Plugin for AudioPreviewPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<AudioPreviewState>()
+            .add_systems(Update, update_audio_preview)
+            .add_systems(OnEnter(EditorMode::Playing), stop_audio_preview);
+    }
+}
+
+pub fn audition_audio_source(world: &mut World, source: Entity) -> Result<(), String> {
+    ensure_edit_mode(world)?;
+    let descriptor = world
+        .get::<AudioSourceDesc>(source)
+        .cloned()
+        .ok_or_else(|| "Selected actor has no AudioSourceDesc".to_string())?;
+    let path = descriptor
+        .clip
+        .as_ref()
+        .and_then(|clip| clip.source_path.as_deref())
+        .filter(|path| !path.trim().is_empty())
+        .ok_or_else(|| "Assign an audio clip before auditioning this source".to_string())?
+        .to_string();
+    spawn_preview(world, path, Some((source, descriptor)))
+}
+
+pub fn audition_audio_asset(world: &mut World, asset: &EditorAsset) -> Result<(), String> {
+    ensure_edit_mode(world)?;
+    if !matches!(asset.kind, EditorAssetKind::AudioClip) {
+        return Err("Selected asset is not an audio clip".into());
+    }
+    let path = asset
+        .path
+        .as_deref()
+        .filter(|path| !path.trim().is_empty())
+        .ok_or_else(|| "Audio clip has no project path".to_string())?
+        .to_string();
+    spawn_preview(world, path, None)
+}
+
+fn ensure_edit_mode(world: &World) -> Result<(), String> {
+    if *world.resource::<State<EditorMode>>().get() != EditorMode::Editing {
+        return Err("Audio audition is available only in Edit mode".into());
+    }
+    Ok(())
+}
+
+fn spawn_preview(
+    world: &mut World,
+    path: String,
+    source: Option<(Entity, AudioSourceDesc)>,
+) -> Result<(), String> {
+    stop_audio_preview(world);
+    let descriptor = source
+        .as_ref()
+        .map(|(_, descriptor)| descriptor.clone())
+        .unwrap_or_else(|| AudioSourceDesc {
+            autoplay: false,
+            spatial_blend: 0.0,
+            bus: AUDIO_BUS_SFX_ID.into(),
+            ..Default::default()
+        });
+    let source_entity = source.as_ref().map(|(entity, _)| *entity);
+    let mixes = game::audio::audio_voice_mix(descriptor.spatial_blend);
+    let panning_scale = game::audio::spatial_panning_scale(&descriptor.attenuation, 0.2);
+    let needs_listener = mixes.iter().any(|(spatial, _)| *spatial);
+    let listener = if needs_listener {
+        let mut query = world
+            .query_filtered::<(Entity, &GlobalTransform, Has<SpatialListener>), With<EditorCamera>>(
+            );
+        Some(
+            query
+                .iter(world)
+                .next()
+                .map(|(entity, transform, has_listener)| (entity, *transform, has_listener))
+                .ok_or_else(|| "Editor camera is unavailable for spatial audition".to_string())?,
+        )
+    } else {
+        None
+    };
+    let listener = listener.map(|(camera, camera_transform, has_listener)| {
+        if has_listener {
+            camera
+        } else {
+            world
+                .spawn((
+                    Name::new("Editor Audio Preview Listener"),
+                    EditorOnly,
+                    Transform::IDENTITY,
+                    camera_transform,
+                    SpatialListener::new(0.2),
+                    EditorAudioPreviewListener,
+                    ChildOf(camera),
+                ))
+                .id()
+        }
+    });
+
+    let asset_server = world.resource::<AssetServer>().clone();
+    let handle: Handle<AudioSource> = asset_server.load(asset_server_path(&path));
+    let mut voices = Vec::with_capacity(mixes.len());
+    for (spatial, mix_weight) in mixes {
+        let mut voice = world.spawn((
+            Name::new(if spatial {
+                "Editor Spatial Audio Preview"
+            } else {
+                "Editor 2D Audio Preview"
+            }),
+            EditorOnly,
+            Transform::IDENTITY,
+            AudioPlayer::new(handle.clone()),
+            PlaybackSettings {
+                mode: PlaybackMode::Once,
+                volume: Volume::Linear(0.0),
+                speed: descriptor.pitch,
+                paused: false,
+                muted: false,
+                spatial,
+                spatial_scale: spatial.then(|| SpatialScale::new(panning_scale)),
+                start_position: None,
+                duration: None,
+            },
+            AudioPreviewVoice {
+                source: source_entity,
+                bus: descriptor.bus.clone(),
+                source_gain_db: descriptor.gain_db,
+                mix_weight,
+                spatial,
+                attenuation: descriptor.attenuation,
+            },
+        ));
+        if let Some(source) = source_entity {
+            voice.insert(ChildOf(source));
+        }
+        voices.push(voice.id());
+    }
+    *world.resource_mut::<AudioPreviewState>() = AudioPreviewState {
+        voices,
+        source: source_entity,
+        clip_path: Some(path.clone()),
+        status: format!("Auditioning {}", file_label(&path)),
+        clip_handle: Some(handle),
+        listener,
+    };
+    Ok(())
+}
+
+fn file_label(path: &str) -> &str {
+    std::path::Path::new(path)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or(path)
+}
+
+pub fn stop_audio_preview(world: &mut World) {
+    stop_audio_preview_with_status(world, "Audio preview stopped");
+}
+
+fn stop_audio_preview_with_status(world: &mut World, status: impl Into<String>) {
+    let voices = std::mem::take(&mut world.resource_mut::<AudioPreviewState>().voices);
+    for voice in voices {
+        if let Some(sink) = world.get::<AudioSink>(voice) {
+            sink.stop();
+        }
+        if let Some(sink) = world.get::<SpatialAudioSink>(voice) {
+            sink.stop();
+        }
+        if let Ok(entity_mut) = world.get_entity_mut(voice) {
+            entity_mut.despawn();
+        }
+    }
+    let mut query = world.query_filtered::<Entity, With<EditorAudioPreviewListener>>();
+    let listeners: Vec<Entity> = query.iter(world).collect();
+    for listener in listeners {
+        if let Ok(entity_mut) = world.get_entity_mut(listener) {
+            entity_mut.despawn();
+        }
+    }
+    let state = world.resource_mut::<AudioPreviewState>().into_inner();
+    state.source = None;
+    state.clip_path = None;
+    state.clip_handle = None;
+    state.listener = None;
+    state.status = status.into();
+}
+
+fn update_audio_preview(world: &mut World) {
+    let state = world.resource::<AudioPreviewState>().clone();
+    if state.voices.is_empty() {
+        return;
+    }
+    if *world.resource::<State<EditorMode>>().get() != EditorMode::Editing {
+        stop_audio_preview_with_status(world, "Audio preview stopped on entering Play mode");
+        return;
+    }
+    if state.source.is_some_and(|source| {
+        world.get_entity(source).is_err() || world.get::<AudioSourceDesc>(source).is_none()
+    }) {
+        stop_audio_preview_with_status(world, "Audio preview stopped because its source changed");
+        return;
+    }
+    if state
+        .listener
+        .is_some_and(|listener| world.get::<GlobalTransform>(listener).is_none())
+    {
+        stop_audio_preview_with_status(
+            world,
+            "Audio preview stopped because the editor camera changed",
+        );
+        return;
+    }
+    if let Some(LoadState::Failed(error)) = state
+        .clip_handle
+        .as_ref()
+        .map(|handle| world.resource::<AssetServer>().load_state(handle.id()))
+    {
+        let status = format!("Audio preview failed: {error}");
+        stop_audio_preview_with_status(world, status.clone());
+        if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
+            scene_io.set_status(status);
+        }
+        return;
+    }
+
+    let listener_position = state
+        .listener
+        .and_then(|listener| world.get::<GlobalTransform>(listener))
+        .map(GlobalTransform::translation);
+    let project_audio = world.resource::<settings::ProjectSettings>().audio.clone();
+    let bus_runtime = world.resource::<game::audio::AudioBusRuntime>().clone();
+    let mut finished = 0usize;
+    for voice_entity in &state.voices {
+        let Some(voice) = world.get::<AudioPreviewVoice>(*voice_entity).cloned() else {
+            finished += 1;
+            continue;
+        };
+        let source_position = voice
+            .source
+            .and_then(|source| world.get::<GlobalTransform>(source))
+            .map(GlobalTransform::translation);
+        let attenuation = if voice.spatial {
+            match (listener_position, source_position) {
+                (Some(listener), Some(source)) => {
+                    game::audio::attenuation_gain(&voice.attenuation, listener.distance(source))
+                }
+                _ => 0.0,
+            }
+        } else {
+            1.0
+        };
+        let gain = game::audio::db_to_linear(voice.source_gain_db)
+            * game::audio::effective_bus_gain_linear(&project_audio, &bus_runtime, &voice.bus)
+            * voice.mix_weight
+            * attenuation;
+        if let Some(mut sink) = world.get_mut::<AudioSink>(*voice_entity) {
+            sink.set_volume(Volume::Linear(gain));
+            if sink.empty() {
+                finished += 1;
+            }
+        } else if let Some(mut sink) = world.get_mut::<SpatialAudioSink>(*voice_entity) {
+            sink.set_volume(Volume::Linear(gain));
+            if sink.empty() {
+                finished += 1;
+            }
+        }
+    }
+    if finished == state.voices.len() {
+        stop_audio_preview_with_status(world, "Audio preview finished");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::{AssetApp, AssetPlugin};
+    use bevy::state::app::StatesPlugin;
+    use shared::{EditorAssetRef, AUDIO_CLIP_SUB_ASSET_ID};
+
+    #[test]
+    fn file_label_is_stable_for_project_paths() {
+        assert_eq!(file_label("assets/audio/impact.ogg"), "impact.ogg");
+        assert_eq!(file_label("clip.wav"), "clip.wav");
+    }
+
+    fn preview_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((MinimalPlugins, AssetPlugin::default(), StatesPlugin))
+            .init_asset::<AudioSource>()
+            .init_state::<EditorMode>()
+            .add_plugins(AudioPreviewPlugin)
+            .init_resource::<crate::scene_io::SceneIo>()
+            .init_resource::<crate::history::EditorHistory>()
+            .init_resource::<game::audio::AudioBusRuntime>()
+            .insert_resource(settings::ProjectSettings::default());
+        app
+    }
+
+    fn spawn_camera(app: &mut App, listener: Option<SpatialListener>) -> Entity {
+        let mut camera = app.world_mut().spawn((
+            EditorCamera::default(),
+            Transform::IDENTITY,
+            GlobalTransform::IDENTITY,
+        ));
+        if let Some(listener) = listener {
+            camera.insert(listener);
+        }
+        camera.id()
+    }
+
+    fn spawn_source(app: &mut App) -> Entity {
+        app.world_mut()
+            .spawn((
+                Transform::from_xyz(0.0, 0.0, -2.0),
+                GlobalTransform::IDENTITY,
+                AudioSourceDesc {
+                    clip: Some(
+                        EditorAssetRef::new("audio-id", AUDIO_CLIP_SUB_ASSET_ID, "Impact")
+                            .with_source_path("assets/audio/impact.ogg"),
+                    ),
+                    ..Default::default()
+                },
+            ))
+            .id()
+    }
+
+    #[test]
+    fn audition_and_stop_do_not_dirty_scene_or_push_history() {
+        let mut app = preview_app();
+        spawn_camera(&mut app, None);
+        let source = spawn_source(&mut app);
+
+        audition_audio_source(app.world_mut(), source).unwrap();
+
+        assert!(!app
+            .world()
+            .resource::<AudioPreviewState>()
+            .voices
+            .is_empty());
+        assert!(!app.world().resource::<crate::scene_io::SceneIo>().dirty);
+        assert_eq!(
+            app.world()
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            0
+        );
+
+        stop_audio_preview(app.world_mut());
+
+        assert!(app
+            .world()
+            .resource::<AudioPreviewState>()
+            .voices
+            .is_empty());
+        assert!(!app.world().resource::<crate::scene_io::SceneIo>().dirty);
+        assert_eq!(
+            app.world()
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            0
+        );
+    }
+
+    #[test]
+    fn spatial_preview_preserves_an_existing_editor_camera_listener() {
+        let mut app = preview_app();
+        let camera = spawn_camera(&mut app, Some(SpatialListener::new(0.5)));
+        let source = spawn_source(&mut app);
+        let expected = app.world().get::<SpatialListener>(camera).unwrap().clone();
+
+        audition_audio_source(app.world_mut(), source).unwrap();
+
+        let actual = app.world().get::<SpatialListener>(camera).unwrap();
+        assert_eq!(actual.left_ear_offset, expected.left_ear_offset);
+        assert_eq!(actual.right_ear_offset, expected.right_ear_offset);
+        assert_eq!(
+            app.world().resource::<AudioPreviewState>().listener,
+            Some(camera)
+        );
+        let mut preview_listeners = app
+            .world_mut()
+            .query_filtered::<Entity, With<EditorAudioPreviewListener>>();
+        assert_eq!(preview_listeners.iter(app.world()).count(), 0);
+
+        stop_audio_preview(app.world_mut());
+
+        let actual = app.world().get::<SpatialListener>(camera).unwrap();
+        assert_eq!(actual.left_ear_offset, expected.left_ear_offset);
+        assert_eq!(actual.right_ear_offset, expected.right_ear_offset);
+    }
+
+    #[test]
+    fn source_component_removal_cleans_up_preview() {
+        let mut app = preview_app();
+        spawn_camera(&mut app, None);
+        let source = spawn_source(&mut app);
+        audition_audio_source(app.world_mut(), source).unwrap();
+
+        app.world_mut()
+            .entity_mut(source)
+            .remove::<AudioSourceDesc>();
+        update_audio_preview(app.world_mut());
+
+        let state = app.world().resource::<AudioPreviewState>();
+        assert!(state.voices.is_empty());
+        assert!(state.source.is_none());
+        assert!(state.status.contains("source changed"));
+    }
+
+    #[test]
+    fn entering_play_mode_cleans_up_preview() {
+        let mut app = preview_app();
+        spawn_camera(&mut app, None);
+        let source = spawn_source(&mut app);
+        audition_audio_source(app.world_mut(), source).unwrap();
+
+        app.world_mut()
+            .resource_mut::<NextState<EditorMode>>()
+            .set(EditorMode::Playing);
+        app.update();
+
+        let state = app.world().resource::<AudioPreviewState>();
+        assert!(state.voices.is_empty());
+        assert!(state.source.is_none());
+        let mut preview_listeners = app
+            .world_mut()
+            .query_filtered::<Entity, With<EditorAudioPreviewListener>>();
+        assert_eq!(preview_listeners.iter(app.world()).count(), 0);
+    }
+}
diff --git a/crates/editor/src/play/mod.rs b/crates/editor/src/play/mod.rs
index 517f11c..13759b1 100644
--- a/crates/editor/src/play/mod.rs
+++ b/crates/editor/src/play/mod.rs
@@ -1,5 +1,6 @@
 //! Play-in-editor session, editor mode state, and net editor profiles.
 
+pub mod audio_preview;
 pub mod net_editor;
 mod session;
 pub mod state;
diff --git a/crates/editor/src/play/state.rs b/crates/editor/src/play/state.rs
index d5262d5..aaf9161 100644
--- a/crates/editor/src/play/state.rs
+++ b/crates/editor/src/play/state.rs
@@ -7,7 +7,6 @@ use protocol::PlayerInputIntent;
 use sim::{Crouching, Grounded, JumpState, Player, PlayerVelocity};
 
 use crate::camera::EditorCamera;
-use crate::scene_io::SceneIo;
 
 /// Editor/game mode. `Playing` runs the real game sim; use [`PlayPossession`] for camera control.
 #[derive(States, Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
@@ -252,6 +251,8 @@ fn sync_play_input_focus(
 }
 
 fn enter_play_mode(world: &mut World) {
+    // Edit-mode scrubbing must not override authored controller playback in PIE.
+    game::animation::stop_animation_preview(world);
     let snapshot = snapshot_player_sim(world);
     world.resource_mut::<PlayModeSnapshot>().player = Some(snapshot);
 }
@@ -260,9 +261,9 @@ fn exit_play_mode(world: &mut World) {
     if let Some(snapshot) = world.resource_mut::<PlayModeSnapshot>().player.take() {
         restore_player_sim(world, &snapshot);
     }
-    if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
-        scene_io.dirty = true;
-    }
+    world.resource_mut::<SimEnabled>().0 = false;
+    game::animation::reset_authored_animation_runtime(world);
+    game::audio::reset_authored_audio_runtime(world);
 }
 
 fn snapshot_player_sim(world: &mut World) -> PlayerSimSnapshot {
diff --git a/crates/editor/src/project/diagnostics_bundle.rs b/crates/editor/src/project/diagnostics_bundle.rs
new file mode 100644
index 0000000..de64632
--- /dev/null
+++ b/crates/editor/src/project/diagnostics_bundle.rs
@@ -0,0 +1,278 @@
+//! Privacy-bounded support bundle export for editor troubleshooting.
+
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use bevy::prelude::*;
+use bevy::render::renderer::RenderAdapterInfo;
+use serde::{Deserialize, Serialize};
+use shared::{brush_math::validate_brush, BrushDesc, LevelObject};
+
+use crate::project_io::ProjectWorkspace;
+use crate::scene::recovery::{atomic_write, default_state_root};
+use crate::scene_io::{SceneIo, SceneIoEventSeverity};
+use crate::session::EditorSessionRuntime;
+
+const DIAGNOSTICS_SCHEMA_VERSION: u32 = 1;
+const DIAGNOSTICS_DIR: &str = "diagnostics";
+const MAX_EVENT_MESSAGE_CHARS: usize = 512;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DiagnosticBuildInfo {
+    pub editor_version: String,
+    pub bevy_version: String,
+    pub target_os: String,
+    pub target_arch: String,
+    pub build_profile: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DiagnosticRendererInfo {
+    pub adapter_name: String,
+    pub device_type: String,
+    pub backend: String,
+    pub driver: String,
+    pub driver_info: String,
+    pub vendor_id: u32,
+    pub device_id: u32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DiagnosticProjectInfo {
+    pub project_root: String,
+    pub settings_path: String,
+    pub active_scene: Option<String>,
+    pub scene_dirty: bool,
+    pub project_settings_dirty: bool,
+    pub layout_dirty: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DiagnosticValidationSummary {
+    pub level_object_count: usize,
+    pub brush_actor_count: usize,
+    pub invalid_brush_count: usize,
+    pub brush_error_count: usize,
+    pub brush_warning_count: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DiagnosticSceneIoEvent {
+    pub id: u64,
+    pub severity: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DiagnosticBundleDocument {
+    pub schema_version: u32,
+    pub created_unix_seconds: u64,
+    pub build: DiagnosticBuildInfo,
+    pub renderer: Option<DiagnosticRendererInfo>,
+    pub project: DiagnosticProjectInfo,
+    pub validation: DiagnosticValidationSummary,
+    pub prior_abnormal_shutdown: bool,
+    pub scene_io_events: Vec<DiagnosticSceneIoEvent>,
+}
+
+/// Writes an allowlisted support report without scene data, environment values, or credentials.
+pub fn export_diagnostic_bundle(world: &mut World) -> Result<PathBuf, String> {
+    let document = capture_diagnostic_bundle(world);
+    let directory = default_state_root()
+        .ok_or_else(|| "XDG_STATE_HOME and HOME are both unavailable".to_string())?
+        .join(DIAGNOSTICS_DIR);
+    let timestamp = document.created_unix_seconds;
+    let path = directory.join(format!(
+        "blacksite-diagnostics-{timestamp:020}-{}.ron",
+        std::process::id()
+    ));
+    let text = serialize_diagnostic_bundle(&document)?;
+    atomic_write(&path, text.as_bytes())?;
+    Ok(path)
+}
+
+fn capture_diagnostic_bundle(world: &mut World) -> DiagnosticBundleDocument {
+    let validation = validation_summary(world);
+    let renderer =
+        world
+            .get_resource::<RenderAdapterInfo>()
+            .map(|adapter| DiagnosticRendererInfo {
+                adapter_name: adapter.name.clone(),
+                device_type: format!("{:?}", adapter.device_type),
+                backend: format!("{:?}", adapter.backend),
+                driver: adapter.driver.clone(),
+                driver_info: adapter.driver_info.clone(),
+                vendor_id: adapter.vendor,
+                device_id: adapter.device,
+            });
+    let scene_io = world.resource::<SceneIo>();
+    let workspace = world.resource::<ProjectWorkspace>();
+    let project = DiagnosticProjectInfo {
+        project_root: workspace.root.clone(),
+        settings_path: workspace.settings_path.clone(),
+        active_scene: scene_io
+            .active_path
+            .as_ref()
+            .map(|path| path.display().to_string()),
+        scene_dirty: scene_io.has_unsaved_tabs(),
+        project_settings_dirty: workspace.settings_dirty,
+        layout_dirty: workspace.layout_dirty,
+    };
+    let scene_io_events = scene_io
+        .events
+        .iter()
+        .map(|event| DiagnosticSceneIoEvent {
+            id: event.id,
+            severity: match event.severity {
+                SceneIoEventSeverity::Info => "info",
+                SceneIoEventSeverity::Error => "error",
+            }
+            .to_string(),
+            message: bounded_message(&event.message),
+        })
+        .collect();
+
+    DiagnosticBundleDocument {
+        schema_version: DIAGNOSTICS_SCHEMA_VERSION,
+        created_unix_seconds: SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs(),
+        build: build_info(),
+        renderer,
+        project,
+        validation,
+        prior_abnormal_shutdown: world
+            .get_resource::<EditorSessionRuntime>()
+            .is_some_and(|runtime| runtime.prior_abnormal_shutdown),
+        scene_io_events,
+    }
+}
+
+fn validation_summary(world: &mut World) -> DiagnosticValidationSummary {
+    let mut level_query = world.query_filtered::<Entity, With<LevelObject>>();
+    let level_object_count = level_query.iter(world).count();
+    let mut brush_query = world.query_filtered::<&BrushDesc, With<LevelObject>>();
+    let mut summary = DiagnosticValidationSummary {
+        level_object_count,
+        brush_actor_count: 0,
+        invalid_brush_count: 0,
+        brush_error_count: 0,
+        brush_warning_count: 0,
+    };
+    for brush in brush_query.iter(world) {
+        summary.brush_actor_count += 1;
+        let report = validate_brush(brush);
+        let errors = report
+            .diagnostics
+            .iter()
+            .filter(|diagnostic| {
+                diagnostic.severity == shared::brush_math::BrushDiagnosticSeverity::Error
+            })
+            .count();
+        let warnings = report.diagnostics.len().saturating_sub(errors);
+        summary.brush_error_count += errors;
+        summary.brush_warning_count += warnings;
+        summary.invalid_brush_count += usize::from(errors > 0);
+    }
+    summary
+}
+
+fn build_info() -> DiagnosticBuildInfo {
+    DiagnosticBuildInfo {
+        editor_version: env!("CARGO_PKG_VERSION").to_string(),
+        bevy_version: "0.19".to_string(),
+        target_os: std::env::consts::OS.to_string(),
+        target_arch: std::env::consts::ARCH.to_string(),
+        build_profile: if cfg!(debug_assertions) {
+            "debug"
+        } else {
+            "release"
+        }
+        .to_string(),
+    }
+}
+
+fn bounded_message(message: &str) -> String {
+    message
+        .chars()
+        .filter(|character| !character.is_control() || *character == ' ')
+        .take(MAX_EVENT_MESSAGE_CHARS)
+        .collect()
+}
+
+fn serialize_diagnostic_bundle(document: &DiagnosticBundleDocument) -> Result<String, String> {
+    ron::ser::to_string_pretty(document, ron::ser::PrettyConfig::default())
+        .map_err(|error| format!("could not serialize diagnostics: {error}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixture() -> DiagnosticBundleDocument {
+        DiagnosticBundleDocument {
+            schema_version: DIAGNOSTICS_SCHEMA_VERSION,
+            created_unix_seconds: 42,
+            build: build_info(),
+            renderer: None,
+            project: DiagnosticProjectInfo {
+                project_root: "/project".to_string(),
+                settings_path: "assets/project.ron".to_string(),
+                active_scene: Some("assets/levels/test.scn.ron".to_string()),
+                scene_dirty: true,
+                project_settings_dirty: false,
+                layout_dirty: false,
+            },
+            validation: DiagnosticValidationSummary {
+                level_object_count: 12,
+                brush_actor_count: 2,
+                invalid_brush_count: 1,
+                brush_error_count: 1,
+                brush_warning_count: 0,
+            },
+            prior_abnormal_shutdown: true,
+            scene_io_events: vec![DiagnosticSceneIoEvent {
+                id: 1,
+                severity: "error".to_string(),
+                message: "Save failed: disk full".to_string(),
+            }],
+        }
+    }
+
+    #[test]
+    fn serialized_bundle_contains_only_allowlisted_sections() {
+        let text = serialize_diagnostic_bundle(&fixture()).unwrap();
+
+        for allowed in [
+            "build",
+            "renderer",
+            "project",
+            "validation",
+            "scene_io_events",
+        ] {
+            assert!(text.contains(allowed));
+        }
+        for forbidden in [
+            "scene_contents",
+            "asset_contents",
+            "environment",
+            "credential",
+            "access_token",
+            "hostname",
+            "username",
+            "modal_operator",
+        ] {
+            assert!(!text.to_ascii_lowercase().contains(forbidden));
+        }
+    }
+
+    #[test]
+    fn event_messages_are_control_free_and_bounded() {
+        let message = format!("failure\n{}", "x".repeat(MAX_EVENT_MESSAGE_CHARS + 20));
+        let bounded = bounded_message(&message);
+
+        assert!(bounded.chars().count() <= MAX_EVENT_MESSAGE_CHARS);
+        assert!(!bounded.contains('\n'));
+    }
+}
diff --git a/crates/editor/src/project/launcher.rs b/crates/editor/src/project/launcher.rs
new file mode 100644
index 0000000..65a6bcb
--- /dev/null
+++ b/crates/editor/src/project/launcher.rs
@@ -0,0 +1,847 @@
+//! Pre-engine project validation, recent-project discovery, and sandbox scaffolding.
+
+use std::collections::HashSet;
+use std::path::{Component, Path, PathBuf};
+use std::process::Command;
+
+use bevy::app::AppExit;
+use bevy::prelude::*;
+use bevy::window::{CompositeAlphaMode, PresentMode, WindowPlugin};
+use bevy_egui::{egui, EguiContext, EguiPlugin, EguiPrimaryContextPass, PrimaryEguiContext};
+use settings::{
+    save_project_settings_to_string, ProjectKind, ProjectSettings, DEFAULT_PROJECT_PATH,
+    PROJECT_TEMPLATE_VERSION,
+};
+
+use crate::project_io::UserPreferences;
+use crate::scene::recovery::atomic_write;
+use crate::ui::theme::{
+    apply_editor_theme, ACCENT, BORDER, CANVAS_BG, PANEL_BG, PANEL_BG_DARK, SELECTION, TEXT,
+    TEXT_DIM, TEXT_MUTED,
+};
+
+const SANDBOX_DIRECTORIES: &[&str] = &[
+    "assets/.index",
+    "assets/.trash",
+    "assets/audio",
+    "assets/build_profiles",
+    "assets/levels",
+    "assets/materials",
+    "assets/meshes/generated",
+    "assets/models",
+    "assets/post_fx",
+    "assets/rendering_profiles",
+    "assets/shaders",
+    "assets/textures",
+];
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ProjectSummary {
+    pub root: PathBuf,
+    pub project_id: String,
+    pub name: String,
+    pub project_kind: ProjectKind,
+    pub template_version: u32,
+    pub capabilities: Vec<String>,
+    pub default_level: PathBuf,
+    pub last_scene: Option<PathBuf>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct StartupArguments {
+    pub project: Option<PathBuf>,
+    pub help: bool,
+}
+
+#[derive(Resource)]
+struct ProjectLauncherUi {
+    recents: Vec<ProjectSummary>,
+    sandbox_name: String,
+    sandbox_destination: Option<PathBuf>,
+    status: Option<String>,
+}
+
+impl Default for ProjectLauncherUi {
+    fn default() -> Self {
+        let mut preferences = crate::project_io::read_user_preferences();
+        if let Ok(root) = std::env::current_dir().and_then(|root| root.canonicalize()) {
+            crate::project_io::remember_project_root(&mut preferences, &root);
+        }
+        Self {
+            recents: recent_project_summaries(&preferences),
+            sandbox_name: "New Sandbox".to_string(),
+            sandbox_destination: None,
+            status: None,
+        }
+    }
+}
+
+pub fn run_project_launcher() {
+    let mut app = App::new();
+    app.add_plugins(DefaultPlugins.set(WindowPlugin {
+        primary_window: Some(Window {
+            title: "Blacksite Project Browser".to_string(),
+            name: Some("blacksite-project-launcher".to_string()),
+            resolution: (960, 620).into(),
+            present_mode: PresentMode::AutoVsync,
+            transparent: false,
+            composite_alpha_mode: CompositeAlphaMode::Opaque,
+            ..default()
+        }),
+        ..default()
+    }))
+    .add_plugins(EguiPlugin::default())
+    .init_resource::<ProjectLauncherUi>()
+    .add_systems(Startup, spawn_project_launcher_camera)
+    .add_systems(EguiPrimaryContextPass, project_launcher_ui_system);
+    app.run();
+}
+
+fn spawn_project_launcher_camera(mut commands: Commands) {
+    commands.spawn((Camera2d, PrimaryEguiContext));
+}
+
+pub fn spawn_project_launcher_process() -> Result<(), String> {
+    let executable = sibling_executable("project_launcher")?;
+    let root = std::env::current_dir()
+        .map_err(|error| format!("could not resolve active project root: {error}"))?;
+    spawn_detached(&executable, &[], &root)
+}
+
+pub fn reveal_project_root(root: &Path) -> Result<(), String> {
+    Command::new("xdg-open")
+        .arg(root)
+        .spawn()
+        .map_err(|error| format!("could not reveal {}: {error}", root.display()))?;
+    Ok(())
+}
+
+fn project_launcher_ui_system(world: &mut World) {
+    let Ok(context) = world
+        .query_filtered::<&mut EguiContext, With<PrimaryEguiContext>>()
+        .single(world)
+    else {
+        return;
+    };
+    let mut context = context.clone();
+    world.resource_scope(|world, mut state: Mut<ProjectLauncherUi>| {
+        project_launcher_ui(world, context.get_mut(), &mut state);
+    });
+}
+
+#[expect(
+    deprecated,
+    reason = "bevy_egui exposes a Context during EguiPrimaryContextPass, requiring one top-level context-based panel"
+)]
+fn project_launcher_ui(world: &mut World, context: &egui::Context, state: &mut ProjectLauncherUi) {
+    apply_editor_theme(context);
+    egui::CentralPanel::default()
+        .frame(
+            egui::Frame::new()
+                .fill(CANVAS_BG)
+                .inner_margin(egui::Margin::same(24)),
+        )
+        .show(context, |ui| {
+            let content_width = ui.available_width().min(1240.0);
+            let side_space = ((ui.available_width() - content_width) * 0.5).max(0.0);
+            ui.horizontal(|ui| {
+                ui.add_space(side_space);
+                ui.vertical(|ui| {
+                    ui.set_width(content_width);
+                    ui.horizontal(|ui| {
+                        ui.vertical(|ui| {
+                            ui.label(
+                                egui::RichText::new("BLACKSITE")
+                                    .size(22.0)
+                                    .strong()
+                                    .color(ACCENT),
+                            );
+                            ui.label(
+                                egui::RichText::new("PROJECT BROWSER")
+                                    .size(11.0)
+                                    .color(TEXT_DIM),
+                            );
+                        });
+                        ui.add_space(18.0);
+                        ui.separator();
+                        ui.add_space(10.0);
+                        ui.label(
+                            egui::RichText::new(
+                                "Choose a validated workspace before the engine starts",
+                            )
+                            .color(TEXT_DIM),
+                        );
+                    });
+                    ui.add_space(22.0);
+
+                    ui.horizontal(|ui| {
+                        ui.vertical(|ui| {
+                            ui.set_width(340.0);
+                            launcher_actions(world, ui, state);
+                        });
+                        ui.add_space(18.0);
+                        ui.vertical(|ui| {
+                            ui.set_width((content_width - 358.0).max(360.0));
+                            recent_projects(world, ui, state);
+                        });
+                    });
+
+                    if let Some(status) = state.status.as_deref() {
+                        ui.add_space(12.0);
+                        ui.separator();
+                        ui.label(egui::RichText::new(status).color(TEXT_DIM));
+                    }
+                });
+            });
+        });
+}
+
+fn launcher_actions(world: &mut World, ui: &mut egui::Ui, state: &mut ProjectLauncherUi) {
+    egui::Frame::new()
+        .fill(PANEL_BG_DARK)
+        .stroke(egui::Stroke::new(1.0, BORDER))
+        .inner_margin(egui::Margin::same(16))
+        .show(ui, |ui| {
+            ui.set_min_height(455.0);
+            ui.heading("Open Project");
+            ui.label(
+                egui::RichText::new("Select a root containing assets/project.ron").color(TEXT_DIM),
+            );
+            ui.add_space(8.0);
+            if ui.button("Browse Existing...").clicked() {
+                if let Some(root) = rfd::FileDialog::new().pick_folder() {
+                    open_project_from_launcher(world, state, root);
+                }
+            }
+
+            ui.add_space(24.0);
+            ui.separator();
+            ui.add_space(14.0);
+            ui.heading("New Sandbox");
+            ui.label(
+                egui::RichText::new("Creates a clean content workspace with a valid empty level")
+                    .color(TEXT_DIM),
+            );
+            ui.add_space(8.0);
+            ui.label(egui::RichText::new("Project name").color(TEXT_DIM));
+            ui.text_edit_singleline(&mut state.sandbox_name);
+            ui.add_space(6.0);
+            let destination = state
+                .sandbox_destination
+                .as_ref()
+                .map(|path| path.display().to_string())
+                .unwrap_or_else(|| "No destination selected".to_string());
+            ui.add(
+                egui::Label::new(
+                    egui::RichText::new(destination)
+                        .monospace()
+                        .color(TEXT_MUTED),
+                )
+                .truncate(),
+            );
+            if ui.button("Choose Empty Folder...").clicked() {
+                state.sandbox_destination = rfd::FileDialog::new().pick_folder();
+            }
+            let can_create =
+                state.sandbox_destination.is_some() && !state.sandbox_name.trim().is_empty();
+            if ui
+                .add_enabled(can_create, egui::Button::new("Create And Open Sandbox"))
+                .clicked()
+            {
+                let destination = state.sandbox_destination.clone().unwrap();
+                match scaffold_sandbox_project(&destination, &state.sandbox_name) {
+                    Ok(summary) => launch_editor_and_close(world, state, &summary),
+                    Err(error) => state.status = Some(error),
+                }
+            }
+        });
+}
+
+fn recent_projects(world: &mut World, ui: &mut egui::Ui, state: &mut ProjectLauncherUi) {
+    ui.horizontal(|ui| {
+        ui.heading("Recent Projects");
+        ui.add_space(8.0);
+        ui.label(egui::RichText::new(state.recents.len().to_string()).color(TEXT_MUTED));
+    });
+    ui.label(
+        egui::RichText::new("Missing and invalid projects are filtered automatically")
+            .color(TEXT_DIM),
+    );
+    ui.add_space(10.0);
+    if state.recents.is_empty() {
+        egui::Frame::new()
+            .fill(PANEL_BG)
+            .stroke(egui::Stroke::new(1.0, BORDER))
+            .inner_margin(egui::Margin::same(16))
+            .show(ui, |ui| {
+                ui.label(egui::RichText::new("No valid recent projects").color(TEXT));
+                ui.label(
+                    egui::RichText::new("Browse an existing project or create a sandbox.")
+                        .color(TEXT_DIM),
+                );
+            });
+        return;
+    }
+
+    let recents = state.recents.clone();
+    egui::ScrollArea::vertical()
+        .id_salt("project_launcher_recents")
+        .show(ui, |ui| {
+            for summary in recents {
+                let response = egui::Frame::new()
+                    .fill(PANEL_BG)
+                    .stroke(egui::Stroke::new(1.0, BORDER))
+                    .inner_margin(egui::Margin::same(14))
+                    .show(ui, |ui| {
+                        ui.horizontal(|ui| {
+                            ui.vertical(|ui| {
+                                ui.label(egui::RichText::new(&summary.name).strong().color(TEXT));
+                                ui.label(
+                                    egui::RichText::new(summary.root.display().to_string())
+                                        .monospace()
+                                        .size(11.0)
+                                        .color(TEXT_MUTED),
+                                );
+                                let detail = summary.last_scene.as_ref().map_or_else(
+                                    || format!("{:?}  |  default scene", summary.project_kind),
+                                    |scene| {
+                                        format!(
+                                            "{:?}  |  {}",
+                                            summary.project_kind,
+                                            scene
+                                                .strip_prefix(&summary.root)
+                                                .unwrap_or(scene)
+                                                .display()
+                                        )
+                                    },
+                                );
+                                ui.label(egui::RichText::new(detail).size(11.0).color(TEXT_DIM));
+                            });
+                            ui.with_layout(
+                                egui::Layout::right_to_left(egui::Align::Center),
+                                |ui| {
+                                    if ui.button("Open").clicked() {
+                                        launch_editor_and_close(world, state, &summary);
+                                    }
+                                },
+                            );
+                        });
+                    });
+                if response.response.hovered() {
+                    ui.painter().rect_stroke(
+                        response.response.rect,
+                        0.0,
+                        egui::Stroke::new(1.0, SELECTION),
+                        egui::StrokeKind::Inside,
+                    );
+                }
+                ui.add_space(8.0);
+            }
+        });
+}
+
+fn open_project_from_launcher(world: &mut World, state: &mut ProjectLauncherUi, root: PathBuf) {
+    match inspect_project(&root, None) {
+        Ok(summary) => launch_editor_and_close(world, state, &summary),
+        Err(error) => state.status = Some(error),
+    }
+}
+
+fn launch_editor_and_close(
+    world: &mut World,
+    state: &mut ProjectLauncherUi,
+    summary: &ProjectSummary,
+) {
+    match spawn_editor_process(&summary.root) {
+        Ok(()) => {
+            state.status = Some(format!("Opening {}", summary.name));
+            world.write_message(AppExit::Success);
+        }
+        Err(error) => state.status = Some(error),
+    }
+}
+
+fn spawn_editor_process(root: &Path) -> Result<(), String> {
+    let executable = sibling_executable("editor")?;
+    spawn_detached(
+        &executable,
+        &[std::ffi::OsStr::new("--project"), root.as_os_str()],
+        root,
+    )
+}
+
+#[cfg(target_os = "linux")]
+fn spawn_detached(
+    executable: &Path,
+    arguments: &[&std::ffi::OsStr],
+    cwd: &Path,
+) -> Result<(), String> {
+    let mut command = Command::new("systemd-run");
+    command
+        .args(["--user", "--collect", "--quiet", "--service-type=exec"])
+        .arg(format!("--working-directory={}", cwd.display()));
+    for variable in [
+        "PATH",
+        "WAYLAND_DISPLAY",
+        "DISPLAY",
+        "XAUTHORITY",
+        "XDG_RUNTIME_DIR",
+        "HYPRLAND_INSTANCE_SIGNATURE",
+        "DBUS_SESSION_BUS_ADDRESS",
+        "XDG_CURRENT_DESKTOP",
+        "XDG_SESSION_DESKTOP",
+        "XDG_SESSION_TYPE",
+        "XDG_DATA_HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_STATE_HOME",
+        "GDK_BACKEND",
+        "LD_LIBRARY_PATH",
+        "WGPU_VALIDATION",
+        "BEVY_FPS_HDR",
+    ] {
+        if let Some(value) = std::env::var_os(variable) {
+            command.arg(format!("--setenv={variable}={}", value.to_string_lossy()));
+        }
+    }
+    let status = command
+        .arg(executable)
+        .args(arguments)
+        .status()
+        .map_err(|error| format!("could not invoke systemd-run: {error}"))?;
+    status.success().then_some(()).ok_or_else(|| {
+        format!(
+            "systemd-run could not start {} (status {status})",
+            executable.display()
+        )
+    })
+}
+
+#[cfg(not(target_os = "linux"))]
+fn spawn_detached(
+    executable: &Path,
+    arguments: &[&std::ffi::OsStr],
+    cwd: &Path,
+) -> Result<(), String> {
+    Command::new(executable)
+        .args(arguments)
+        .current_dir(cwd)
+        .spawn()
+        .map_err(|error| format!("could not start {}: {error}", executable.display()))?;
+    Ok(())
+}
+
+fn sibling_executable(name: &str) -> Result<PathBuf, String> {
+    let current = std::env::current_exe()
+        .map_err(|error| format!("could not locate current executable: {error}"))?;
+    let extension = current
+        .extension()
+        .map(|extension| extension.to_os_string());
+    let mut executable = current.with_file_name(name);
+    if let Some(extension) = extension {
+        executable.set_extension(extension);
+    }
+    executable
+        .is_file()
+        .then_some(executable.clone())
+        .ok_or_else(|| format!("required executable is not built: {}", executable.display()))
+}
+
+pub fn parse_startup_arguments(
+    arguments: impl IntoIterator<Item = String>,
+) -> Result<StartupArguments, String> {
+    let mut parsed = StartupArguments::default();
+    let mut arguments = arguments.into_iter();
+    while let Some(argument) = arguments.next() {
+        match argument.as_str() {
+            "--project" => {
+                if parsed.project.is_some() {
+                    return Err("--project may only be provided once".to_string());
+                }
+                let path = arguments
+                    .next()
+                    .ok_or_else(|| "--project requires a project root path".to_string())?;
+                parsed.project = Some(PathBuf::from(path));
+            }
+            "--help" | "-h" => parsed.help = true,
+            unknown => return Err(format!("unknown editor argument `{unknown}`")),
+        }
+    }
+    Ok(parsed)
+}
+
+pub fn command_line_help() -> &'static str {
+    "Blacksite Editor\n\nUSAGE:\n    editor [--project <root>]\n\nOPTIONS:\n    --project <root>  Open a validated Blacksite project before engine startup\n    -h, --help        Print this help"
+}
+
+pub fn activate_project_root(root: &Path) -> Result<ProjectSummary, String> {
+    let summary = inspect_project(root, None)?;
+    std::env::set_current_dir(&summary.root).map_err(|error| {
+        format!(
+            "could not activate project root {}: {error}",
+            summary.root.display()
+        )
+    })?;
+    Ok(summary)
+}
+
+pub fn inspect_project(root: &Path, last_scene: Option<&Path>) -> Result<ProjectSummary, String> {
+    let root = root
+        .canonicalize()
+        .map_err(|error| format!("could not open project root {}: {error}", root.display()))?;
+    if !root.is_dir() {
+        return Err(format!(
+            "project root is not a directory: {}",
+            root.display()
+        ));
+    }
+    let manifest_path = root.join(DEFAULT_PROJECT_PATH);
+    let text = std::fs::read_to_string(&manifest_path)
+        .map_err(|error| format!("could not read {}: {error}", manifest_path.display()))?;
+    let manifest: ProjectSettings = ron::from_str(&text).map_err(|error| {
+        format!(
+            "invalid project manifest {}: {error}",
+            manifest_path.display()
+        )
+    })?;
+    if manifest.name.trim().is_empty() {
+        return Err(format!(
+            "project name is empty in {}",
+            manifest_path.display()
+        ));
+    }
+    manifest.audio.validate().map_err(|error| {
+        format!(
+            "invalid audio settings in {}: {error}",
+            manifest_path.display()
+        )
+    })?;
+    let default_reference = Path::new(&manifest.default_level);
+    if !default_reference.starts_with("assets/levels")
+        || !manifest.default_level.ends_with(".scn.ron")
+    {
+        return Err("default_level must be a .scn.ron scene under assets/levels/".into());
+    }
+    let default_level = safe_project_path(&root, default_reference, "default_level")?;
+    let default_metadata = std::fs::symlink_metadata(&default_level).ok();
+    if !default_metadata
+        .as_ref()
+        .is_some_and(std::fs::Metadata::is_file)
+        || default_metadata.is_some_and(|metadata| metadata.file_type().is_symlink())
+    {
+        return Err(format!(
+            "default level is missing or is not a regular file: {}",
+            default_level.display()
+        ));
+    }
+    let default_level_text = std::fs::read_to_string(&default_level).map_err(|error| {
+        format!(
+            "could not read default level {}: {error}",
+            default_level.display()
+        )
+    })?;
+    scene::validate_level_text(&default_level_text).map_err(|error| {
+        format!(
+            "default level failed validation {}: {error}",
+            default_level.display()
+        )
+    })?;
+    scene::validate_composition_graph(&default_level, &root).map_err(|error| {
+        format!(
+            "default level composition failed validation {}: {error}",
+            default_level.display()
+        )
+    })?;
+
+    let last_scene = last_scene
+        .and_then(|path| safe_project_path(&root, path, "last_scene").ok())
+        .filter(|path| path.is_file());
+    let project_id = if manifest.project_id.trim().is_empty() {
+        format!("legacy:{}", root.display())
+    } else {
+        manifest.project_id
+    };
+    Ok(ProjectSummary {
+        root,
+        project_id,
+        name: manifest.name,
+        project_kind: manifest.project_kind,
+        template_version: manifest.template_version,
+        capabilities: manifest.capabilities,
+        default_level,
+        last_scene,
+    })
+}
+
+pub fn recent_project_summaries(preferences: &UserPreferences) -> Vec<ProjectSummary> {
+    let mut seen = HashSet::new();
+    preferences
+        .recent_projects
+        .iter()
+        .filter_map(|root| {
+            let root = PathBuf::from(root);
+            let last_scene = preferences
+                .recent_levels
+                .iter()
+                .map(PathBuf::from)
+                .find(|scene| root.join(scene).is_file());
+            inspect_project(&root, last_scene.as_deref()).ok()
+        })
+        .filter(|summary| seen.insert(summary.root.clone()))
+        .collect()
+}
+
+pub fn scaffold_sandbox_project(destination: &Path, name: &str) -> Result<ProjectSummary, String> {
+    let name = name.trim();
+    if name.is_empty() {
+        return Err("sandbox project name cannot be empty".to_string());
+    }
+    if destination.exists() {
+        let mut entries = std::fs::read_dir(destination)
+            .map_err(|error| format!("could not inspect {}: {error}", destination.display()))?;
+        if entries.next().is_some() {
+            return Err(format!(
+                "sandbox destination must be empty: {}",
+                destination.display()
+            ));
+        }
+    }
+    for directory in SANDBOX_DIRECTORIES {
+        std::fs::create_dir_all(destination.join(directory)).map_err(|error| {
+            format!(
+                "could not create sandbox directory {}: {error}",
+                destination.join(directory).display()
+            )
+        })?;
+    }
+
+    let default_level = "assets/levels/main.scn.ron";
+    let empty_scene = format!(
+        "(schema_version: {},\n  resources: {{}},\n  entities: {{}},\n)\n",
+        scene::CURRENT_SCENE_SCHEMA_VERSION
+    );
+    scene::validate_level_text(&empty_scene)?;
+    atomic_write(&destination.join(default_level), empty_scene.as_bytes())?;
+
+    let manifest = ProjectSettings {
+        project_id: uuid::Uuid::new_v4().to_string(),
+        name: name.to_string(),
+        project_kind: ProjectKind::Sandbox,
+        template_version: PROJECT_TEMPLATE_VERSION,
+        capabilities: vec![
+            "editor".into(),
+            "gameplay".into(),
+            "rendering".into(),
+            "audio".into(),
+        ],
+        default_level: default_level.to_string(),
+        asset_roots: vec![
+            "assets/audio".into(),
+            "assets/levels".into(),
+            "assets/materials".into(),
+            "assets/meshes".into(),
+            "assets/models".into(),
+            "assets/textures".into(),
+        ],
+        ..ProjectSettings::default()
+    };
+    let manifest_text = save_project_settings_to_string(&manifest)
+        .map_err(|error| format!("could not serialize sandbox manifest: {error}"))?;
+    atomic_write(
+        &destination.join(DEFAULT_PROJECT_PATH),
+        manifest_text.as_bytes(),
+    )?;
+    for (name, profile) in sandbox_build_profiles(default_level) {
+        atomic_write(
+            &destination.join("assets/build_profiles").join(name),
+            profile.as_bytes(),
+        )?;
+    }
+    inspect_project(destination, None)
+}
+
+fn sandbox_build_profiles(default_level: &str) -> [(&'static str, String); 3] {
+    [
+        (
+            "development.ron",
+            format!(
+                "(version:1,name:\"Development\",cargo_profile:Development,target:None,features:[],rendering_tier:\"development\",default_scene:Some(\"{default_level}\"),output_dir:\"dist/development\")\n"
+            ),
+        ),
+        (
+            "qa.ron",
+            format!(
+                "(version:1,name:\"QA\",cargo_profile:Qa,target:None,features:[],rendering_tier:\"representative\",default_scene:Some(\"{default_level}\"),output_dir:\"dist/qa\")\n"
+            ),
+        ),
+        (
+            "release.ron",
+            format!(
+                "(version:1,name:\"Release\",cargo_profile:Release,target:None,features:[],rendering_tier:\"shipping\",default_scene:Some(\"{default_level}\"),output_dir:\"dist/release\")\n"
+            ),
+        ),
+    ]
+}
+
+fn safe_project_path(root: &Path, path: impl AsRef<Path>, field: &str) -> Result<PathBuf, String> {
+    let path = path.as_ref();
+    if path.as_os_str().is_empty() || path.is_absolute() {
+        return Err(format!("{field} must be a non-empty project-relative path"));
+    }
+    if path.components().any(|component| {
+        matches!(
+            component,
+            Component::ParentDir | Component::RootDir | Component::Prefix(_)
+        )
+    }) {
+        return Err(format!("{field} cannot escape the project root"));
+    }
+    Ok(root.join(path))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn temp_root(label: &str) -> PathBuf {
+        std::env::temp_dir().join(format!("blacksite-{label}-{}", uuid::Uuid::new_v4()))
+    }
+
+    #[test]
+    fn startup_arguments_parse_project_and_reject_unknown_flags() {
+        let parsed =
+            parse_startup_arguments(["--project".to_string(), "/tmp/project".to_string()]).unwrap();
+        assert_eq!(parsed.project, Some(PathBuf::from("/tmp/project")));
+        assert!(parse_startup_arguments(["--mystery".to_string()]).is_err());
+        assert!(parse_startup_arguments(["--project".to_string()]).is_err());
+    }
+
+    #[test]
+    fn sandbox_scaffold_can_be_inspected_and_reloaded() {
+        let root = temp_root("sandbox");
+
+        let created = scaffold_sandbox_project(&root, "Prototype").unwrap();
+        let reopened =
+            inspect_project(&root, Some(Path::new("assets/levels/main.scn.ron"))).unwrap();
+
+        assert_eq!(created.project_id, reopened.project_id);
+        assert_eq!(reopened.name, "Prototype");
+        assert_eq!(reopened.project_kind, ProjectKind::Sandbox);
+        assert_eq!(reopened.template_version, PROJECT_TEMPLATE_VERSION);
+        assert!(reopened.capabilities.iter().any(|item| item == "audio"));
+        let manifest = settings::load_project_settings_from_path(
+            root.join(DEFAULT_PROJECT_PATH).to_string_lossy().as_ref(),
+        );
+        assert!(manifest.audio.validate().is_ok());
+        assert!(manifest.audio.bus(settings::AUDIO_BUS_SFX_ID).is_some());
+        assert_eq!(
+            reopened.last_scene,
+            Some(root.join("assets/levels/main.scn.ron"))
+        );
+        for directory in SANDBOX_DIRECTORIES {
+            assert!(root.join(directory).is_dir(), "missing {directory}");
+        }
+        for profile in ["development.ron", "qa.ron", "release.ron"] {
+            let text =
+                std::fs::read_to_string(root.join("assets/build_profiles").join(profile)).unwrap();
+            assert!(text.contains("assets/levels/main.scn.ron"), "{profile}");
+            assert!(text.contains("output_dir"), "{profile}");
+        }
+
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn recent_projects_filter_missing_invalid_and_duplicate_roots() {
+        let valid = temp_root("recent-valid");
+        let invalid = temp_root("recent-invalid");
+        scaffold_sandbox_project(&valid, "Valid").unwrap();
+        std::fs::create_dir_all(&invalid).unwrap();
+        let preferences = UserPreferences {
+            recent_projects: vec![
+                valid.display().to_string(),
+                "/definitely/missing/blacksite-project".to_string(),
+                invalid.display().to_string(),
+                valid.display().to_string(),
+            ],
+            recent_levels: vec!["assets/levels/main.scn.ron".to_string()],
+            ..Default::default()
+        };
+
+        let summaries = recent_project_summaries(&preferences);
+
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].name, "Valid");
+        assert!(summaries[0].last_scene.is_some());
+        std::fs::remove_dir_all(valid).unwrap();
+        std::fs::remove_dir_all(invalid).unwrap();
+    }
+
+    #[test]
+    fn project_inspection_rejects_invalid_audio_bus_graphs() {
+        let root = temp_root("invalid-audio-buses");
+        scaffold_sandbox_project(&root, "Invalid Audio").unwrap();
+        let manifest_path = root.join(DEFAULT_PROJECT_PATH);
+        let mut manifest =
+            settings::load_project_settings_from_path(manifest_path.to_string_lossy().as_ref());
+        manifest
+            .audio
+            .bus_mut(settings::AUDIO_BUS_SFX_ID)
+            .unwrap()
+            .parent = Some("missing".into());
+        std::fs::write(
+            &manifest_path,
+            save_project_settings_to_string(&manifest).unwrap(),
+        )
+        .unwrap();
+
+        let error = inspect_project(&root, None).unwrap_err();
+
+        assert!(error.contains("invalid audio settings"), "{error}");
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn sandbox_scaffold_refuses_nonempty_destination_and_path_escape() {
+        let root = temp_root("sandbox-nonempty");
+        std::fs::create_dir_all(&root).unwrap();
+        std::fs::write(root.join("keep.txt"), "user data").unwrap();
+
+        assert!(scaffold_sandbox_project(&root, "Unsafe").is_err());
+        assert!(safe_project_path(&root, "../outside", "test").is_err());
+        assert_eq!(
+            std::fs::read_to_string(root.join("keep.txt")).unwrap(),
+            "user data"
+        );
+
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn project_default_level_must_use_the_audited_levels_tree() {
+        let root = temp_root("default-level-contract");
+        scaffold_sandbox_project(&root, "Contract").unwrap();
+        std::fs::create_dir_all(root.join("assets/custom")).unwrap();
+        std::fs::write(
+            root.join("assets/custom/start.scn.ron"),
+            format!(
+                "(schema_version:{},resources:{{}},entities:{{}})",
+                scene::CURRENT_SCENE_SCHEMA_VERSION
+            ),
+        )
+        .unwrap();
+        let mut manifest = settings::load_project_settings_from_path(
+            root.join(DEFAULT_PROJECT_PATH).to_string_lossy().as_ref(),
+        );
+        manifest.default_level = "assets/custom/start.scn.ron".into();
+        std::fs::write(
+            root.join(DEFAULT_PROJECT_PATH),
+            save_project_settings_to_string(&manifest).unwrap(),
+        )
+        .unwrap();
+
+        let error = inspect_project(&root, None).unwrap_err();
+
+        assert!(error.contains("assets/levels"), "{error}");
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/crates/editor/src/project/mod.rs b/crates/editor/src/project/mod.rs
index e1fbc7a..373c2e4 100644
--- a/crates/editor/src/project/mod.rs
+++ b/crates/editor/src/project/mod.rs
@@ -1,4 +1,7 @@
 //! Project workspace I/O, settings UI, and recent-level sync.
 
+pub mod diagnostics_bundle;
+pub mod launcher;
 pub mod project_io;
+pub mod session;
 pub mod settings_ui;
diff --git a/crates/editor/src/project/project_io.rs b/crates/editor/src/project/project_io.rs
index c59b7fe..88af911 100644
--- a/crates/editor/src/project/project_io.rs
+++ b/crates/editor/src/project/project_io.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
-use settings::{ProjectSettings, ProjectSettingsIo, DEFAULT_PROJECT_PATH};
+use settings::{ProjectKind, ProjectSettings, ProjectSettingsIo, DEFAULT_PROJECT_PATH};
 
 use crate::scene_io::SceneIo;
 
@@ -10,7 +10,7 @@ const USER_CONFIG_DIR: &str = ".config/bevy-fps";
 const USER_PREFS_FILE: &str = "editor_prefs.ron";
 
 /// User-local editor preferences (not checked into the repo).
-#[derive(Debug, Clone, Default, Serialize, Deserialize, Resource)]
+#[derive(Debug, Clone, Serialize, Deserialize, Resource)]
 pub struct UserPreferences {
     pub recent_projects: Vec<String>,
     pub recent_levels: Vec<String>,
@@ -31,16 +31,53 @@ pub struct UserPreferences {
     pub hierarchy_show_runtime: bool,
     #[serde(default)]
     pub hierarchy_sort_mode: crate::ui::hierarchy_state::HierarchySort,
+    #[serde(default = "default_true")]
+    pub scene_autosave_enabled: bool,
+    #[serde(default = "default_autosave_interval_secs")]
+    pub scene_autosave_interval_secs: u64,
+    #[serde(default = "default_recovery_generations")]
+    pub scene_recovery_generations: usize,
 }
 
 fn default_true() -> bool {
     true
 }
 
+const fn default_autosave_interval_secs() -> u64 {
+    120
+}
+
+const fn default_recovery_generations() -> usize {
+    5
+}
+
+impl Default for UserPreferences {
+    fn default() -> Self {
+        Self {
+            recent_projects: Vec::new(),
+            recent_levels: Vec::new(),
+            last_project_root: None,
+            dock_layout: None,
+            save_before_play: false,
+            hierarchy_filter: String::new(),
+            hierarchy_expanded_paths: Vec::new(),
+            hierarchy_show_generated: true,
+            hierarchy_show_runtime: false,
+            hierarchy_sort_mode: crate::ui::hierarchy_state::HierarchySort::default(),
+            scene_autosave_enabled: true,
+            scene_autosave_interval_secs: default_autosave_interval_secs(),
+            scene_recovery_generations: default_recovery_generations(),
+        }
+    }
+}
+
 /// Active project workspace metadata (mirrors manifest fields in `ProjectSettings`).
 #[derive(Resource, Debug, Clone)]
 pub struct ProjectWorkspace {
     pub root: String,
+    pub project_id: String,
+    pub project_kind: ProjectKind,
+    pub last_opened_scene: Option<String>,
     pub settings_path: String,
     pub settings_dirty: bool,
     pub layout_dirty: bool,
@@ -54,6 +91,9 @@ impl Default for ProjectWorkspace {
             .unwrap_or_else(|| ".".into());
         Self {
             root,
+            project_id: String::new(),
+            project_kind: ProjectKind::default(),
+            last_opened_scene: None,
             settings_path: DEFAULT_PROJECT_PATH.into(),
             settings_dirty: false,
             layout_dirty: false,
@@ -73,7 +113,13 @@ impl Plugin for ProjectIoPlugin {
 }
 
 fn load_user_preferences(mut commands: Commands) {
-    let prefs = read_user_preferences();
+    let mut prefs = read_user_preferences();
+    if let Ok(root) = std::env::current_dir().and_then(|root| root.canonicalize()) {
+        remember_project_root(&mut prefs, &root);
+        if let Err(error) = write_user_preferences(&prefs) {
+            warn!("Failed to remember active project: {error}");
+        }
+    }
     commands.insert_resource(prefs);
 }
 
@@ -85,12 +131,13 @@ pub(crate) fn load_user_preferences_on_startup(commands: Commands) {
 fn sync_workspace_from_settings_system(
     settings: Res<ProjectSettings>,
     settings_io: Res<ProjectSettingsIo>,
+    scene_io: Res<SceneIo>,
     mut workspace: ResMut<ProjectWorkspace>,
 ) {
-    if !settings_io.is_changed() && !settings.is_changed() {
+    if !settings_io.is_changed() && !settings.is_changed() && !scene_io.is_changed() {
         return;
     }
-    sync_workspace_from_settings(&mut workspace, &settings, &settings_io);
+    sync_workspace_from_settings(&mut workspace, &settings, &settings_io, &scene_io);
 }
 
 fn user_prefs_path() -> Option<std::path::PathBuf> {
@@ -127,14 +174,26 @@ pub fn push_recent(list: &mut Vec<String>, entry: String, max: usize) {
     list.truncate(max);
 }
 
+pub fn remember_project_root(preferences: &mut UserPreferences, root: &std::path::Path) {
+    let root = root.display().to_string();
+    push_recent(&mut preferences.recent_projects, root.clone(), 12);
+    preferences.last_project_root = Some(root);
+}
+
 pub fn sync_workspace_from_settings(
     workspace: &mut ProjectWorkspace,
     settings: &ProjectSettings,
     settings_io: &ProjectSettingsIo,
+    scene_io: &SceneIo,
 ) {
+    workspace.project_id.clone_from(&settings.project_id);
+    workspace.project_kind = settings.project_kind;
+    workspace.last_opened_scene = scene_io
+        .active_path
+        .as_ref()
+        .map(|path| path.display().to_string());
     workspace.settings_path = settings_io.path.clone();
     workspace.settings_dirty = settings_io.dirty;
-    let _ = settings;
 }
 
 pub fn window_title(
@@ -160,3 +219,21 @@ pub fn window_title(
     }
     parts.join(" — ")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn remembering_project_deduplicates_and_updates_last_root() {
+        let mut preferences = UserPreferences {
+            recent_projects: vec!["/old".into(), "/project".into()],
+            ..Default::default()
+        };
+
+        remember_project_root(&mut preferences, std::path::Path::new("/project"));
+
+        assert_eq!(preferences.last_project_root.as_deref(), Some("/project"));
+        assert_eq!(preferences.recent_projects, vec!["/project", "/old"]);
+    }
+}
diff --git a/crates/editor/src/project/session.rs b/crates/editor/src/project/session.rs
new file mode 100644
index 0000000..d3dd400
--- /dev/null
+++ b/crates/editor/src/project/session.rs
@@ -0,0 +1,419 @@
+//! Versioned machine-local editor session persistence and crash boundary.
+
+use std::path::{Path, PathBuf};
+
+use bevy::app::AppExit;
+use bevy::prelude::*;
+use bevy_egui::egui;
+use serde::{Deserialize, Serialize};
+
+use crate::project_io::{ProjectWorkspace, UserPreferences};
+use crate::scene::recovery::{atomic_write, default_state_root};
+use crate::scene_io::{SceneIo, SceneIoRequest};
+use crate::settings_ui::ProjectSettingsPanel;
+use crate::ui::{BrushDiagnosticsPanel, DiagnosticsPanel};
+use crate::viewport::rendering_diagnostics::RenderingDiagnosticsPanel;
+use crate::viewport::CameraBookmarks;
+
+const SESSION_FILE: &str = "session.ron";
+const SESSION_SCHEMA_VERSION: u32 = 1;
+const SESSION_WRITE_INTERVAL_SECS: f32 = 2.0;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SessionPanelState {
+    #[serde(default)]
+    pub diagnostics: bool,
+    #[serde(default)]
+    pub brush_diagnostics: bool,
+    #[serde(default)]
+    pub rendering: bool,
+    #[serde(default)]
+    pub project_settings: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CameraBookmarkRecord {
+    pub scene: String,
+    pub translation: [f32; 3],
+    pub rotation: [f32; 4],
+    pub scale: [f32; 3],
+}
+
+impl CameraBookmarkRecord {
+    fn from_transform(scene: String, transform: Transform) -> Self {
+        Self {
+            scene,
+            translation: transform.translation.to_array(),
+            rotation: transform.rotation.to_array(),
+            scale: transform.scale.to_array(),
+        }
+    }
+
+    fn to_transform(&self) -> Transform {
+        Transform {
+            translation: Vec3::from_array(self.translation),
+            rotation: Quat::from_array(self.rotation).normalize(),
+            scale: Vec3::from_array(self.scale),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct EditorSessionDocument {
+    #[serde(default)]
+    pub schema_version: u32,
+    #[serde(default)]
+    pub clean_shutdown: bool,
+    #[serde(default)]
+    pub project_root: String,
+    #[serde(default)]
+    pub active_scene: Option<String>,
+    #[serde(default)]
+    pub dock_layout: Option<String>,
+    #[serde(default)]
+    pub hierarchy_expanded_paths: Vec<String>,
+    #[serde(default)]
+    pub panels: SessionPanelState,
+    #[serde(default)]
+    pub camera_bookmarks: Vec<CameraBookmarkRecord>,
+}
+
+impl Default for EditorSessionDocument {
+    fn default() -> Self {
+        Self {
+            schema_version: SESSION_SCHEMA_VERSION,
+            clean_shutdown: true,
+            project_root: String::new(),
+            active_scene: None,
+            dock_layout: None,
+            hierarchy_expanded_paths: Vec::new(),
+            panels: SessionPanelState::default(),
+            camera_bookmarks: Vec::new(),
+        }
+    }
+}
+
+#[derive(Resource, Debug, Default)]
+pub struct EditorSessionRuntime {
+    pub prior_abnormal_shutdown: bool,
+    pub resume_scene: Option<PathBuf>,
+    pub resume_prompt_open: bool,
+    save_elapsed_secs: f32,
+}
+
+pub struct EditorSessionPlugin;
+
+impl Plugin for EditorSessionPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<EditorSessionRuntime>()
+            .add_systems(Startup, initialize_session)
+            .add_systems(Update, persist_running_session)
+            .add_systems(
+                Last,
+                persist_clean_session_on_exit.after(bevy::window::ExitSystems),
+            );
+    }
+}
+
+pub fn session_resume_window(world: &mut World, ctx: &egui::Context) {
+    let (open, scene) = {
+        let runtime = world.resource::<EditorSessionRuntime>();
+        (runtime.resume_prompt_open, runtime.resume_scene.clone())
+    };
+    if !open {
+        return;
+    }
+    let Some(scene) = scene else {
+        world
+            .resource_mut::<EditorSessionRuntime>()
+            .resume_prompt_open = false;
+        return;
+    };
+
+    egui::Window::new("Recover Editor Session")
+        .collapsible(false)
+        .resizable(false)
+        .anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
+        .show(ctx, |ui| {
+            ui.label("The previous editor session did not close cleanly.");
+            ui.small("The safe startup scene is active. Resume only the last authored scene; modal tools and dirty preview state are never restored.");
+            ui.monospace(scene.display().to_string());
+            ui.separator();
+            ui.horizontal(|ui| {
+                if ui.button("Resume Last Scene").clicked() {
+                    world.resource_mut::<SceneIo>().request =
+                        Some(SceneIoRequest::OpenPath(scene.clone()));
+                    world
+                        .resource_mut::<EditorSessionRuntime>()
+                        .resume_prompt_open = false;
+                }
+                if ui.button("Continue Safe").clicked() {
+                    world
+                        .resource_mut::<EditorSessionRuntime>()
+                        .resume_prompt_open = false;
+                    world
+                        .resource_mut::<SceneIo>()
+                        .set_status("Continued with safe startup after abnormal shutdown");
+                }
+            });
+        });
+}
+
+fn session_path() -> Option<PathBuf> {
+    default_state_root().map(|root| root.join(SESSION_FILE))
+}
+
+fn read_session(path: &Path) -> Result<EditorSessionDocument, String> {
+    let text = std::fs::read_to_string(path)
+        .map_err(|error| format!("could not read {}: {error}", path.display()))?;
+    let document: EditorSessionDocument =
+        ron::from_str(&text).map_err(|error| format!("invalid session document: {error}"))?;
+    normalize_session(document)
+}
+
+fn normalize_session(mut document: EditorSessionDocument) -> Result<EditorSessionDocument, String> {
+    match document.schema_version {
+        0 => document.schema_version = SESSION_SCHEMA_VERSION,
+        SESSION_SCHEMA_VERSION => {}
+        version => {
+            return Err(format!(
+                "session schema {version} is newer than supported {SESSION_SCHEMA_VERSION}"
+            ));
+        }
+    }
+    document.camera_bookmarks.retain(valid_bookmark);
+    Ok(document)
+}
+
+fn valid_bookmark(bookmark: &CameraBookmarkRecord) -> bool {
+    bookmark
+        .translation
+        .iter()
+        .chain(bookmark.rotation.iter())
+        .chain(bookmark.scale.iter())
+        .all(|value| value.is_finite())
+}
+
+fn write_session(path: &Path, document: &EditorSessionDocument) -> Result<(), String> {
+    let text = ron::ser::to_string_pretty(document, ron::ser::PrettyConfig::default())
+        .map_err(|error| format!("could not serialize session: {error}"))?;
+    atomic_write(path, text.as_bytes())
+}
+
+fn initialize_session(world: &mut World) {
+    let previous = session_path().and_then(|path| read_session(&path).ok());
+    let prior_abnormal = previous
+        .as_ref()
+        .is_some_and(|document| !document.clean_shutdown);
+
+    if let Some(document) = previous.as_ref() {
+        restore_non_destructive_session_state(world, document);
+        if !prior_abnormal {
+            restore_active_scene(world, document);
+        }
+    }
+
+    let resume_scene = previous
+        .as_ref()
+        .and_then(|document| document.active_scene.as_deref())
+        .map(PathBuf::from)
+        .filter(|path| path.exists());
+    world.insert_resource(EditorSessionRuntime {
+        prior_abnormal_shutdown: prior_abnormal,
+        resume_prompt_open: prior_abnormal && resume_scene.is_some(),
+        resume_scene,
+        save_elapsed_secs: 0.0,
+    });
+
+    if let Some(path) = session_path() {
+        let document = capture_session(world, false);
+        if let Err(error) = write_session(&path, &document) {
+            warn!("Failed to write running session marker: {error}");
+        }
+    }
+}
+
+fn restore_active_scene(world: &mut World, document: &EditorSessionDocument) {
+    let Some(path) = document.active_scene.as_deref().map(PathBuf::from) else {
+        return;
+    };
+    if path.exists() {
+        world.resource_mut::<SceneIo>().active_path = Some(path);
+    }
+}
+
+fn restore_non_destructive_session_state(world: &mut World, document: &EditorSessionDocument) {
+    let poses = document
+        .camera_bookmarks
+        .iter()
+        .map(|bookmark| (bookmark.scene.clone(), bookmark.to_transform()))
+        .collect();
+    world.resource_mut::<CameraBookmarks>().poses = poses;
+    world.resource_mut::<DiagnosticsPanel>().open = document.panels.diagnostics;
+    world.resource_mut::<BrushDiagnosticsPanel>().open = document.panels.brush_diagnostics;
+    world.resource_mut::<RenderingDiagnosticsPanel>().open = document.panels.rendering;
+    world.resource_mut::<ProjectSettingsPanel>().open = document.panels.project_settings;
+}
+
+fn capture_session(world: &World, clean_shutdown: bool) -> EditorSessionDocument {
+    let prefs = world.resource::<UserPreferences>();
+    EditorSessionDocument {
+        schema_version: SESSION_SCHEMA_VERSION,
+        clean_shutdown,
+        project_root: world.resource::<ProjectWorkspace>().root.clone(),
+        active_scene: world
+            .resource::<SceneIo>()
+            .active_path
+            .as_ref()
+            .map(|path| path.display().to_string()),
+        dock_layout: prefs.dock_layout.clone(),
+        hierarchy_expanded_paths: prefs.hierarchy_expanded_paths.clone(),
+        panels: SessionPanelState {
+            diagnostics: world.resource::<DiagnosticsPanel>().open,
+            brush_diagnostics: world.resource::<BrushDiagnosticsPanel>().open,
+            rendering: world.resource::<RenderingDiagnosticsPanel>().open,
+            project_settings: world.resource::<ProjectSettingsPanel>().open,
+        },
+        camera_bookmarks: world
+            .resource::<CameraBookmarks>()
+            .poses
+            .iter()
+            .map(|(scene, transform)| {
+                CameraBookmarkRecord::from_transform(scene.clone(), *transform)
+            })
+            .collect(),
+    }
+}
+
+fn persist_running_session(world: &mut World) {
+    let delta = world.resource::<Time>().delta_secs();
+    let should_write = {
+        let mut runtime = world.resource_mut::<EditorSessionRuntime>();
+        runtime.save_elapsed_secs += delta;
+        if runtime.save_elapsed_secs < SESSION_WRITE_INTERVAL_SECS {
+            false
+        } else {
+            runtime.save_elapsed_secs = 0.0;
+            true
+        }
+    };
+    if !should_write {
+        return;
+    }
+    let Some(path) = session_path() else {
+        return;
+    };
+    if let Err(error) = write_session(&path, &capture_session(world, false)) {
+        warn!("Failed to persist running editor session: {error}");
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn persist_clean_session_on_exit(
+    mut exits: MessageReader<AppExit>,
+    scene_io: Res<SceneIo>,
+    workspace: Res<ProjectWorkspace>,
+    prefs: Res<UserPreferences>,
+    bookmarks: Res<CameraBookmarks>,
+    diagnostics: Res<DiagnosticsPanel>,
+    brush_diagnostics: Res<BrushDiagnosticsPanel>,
+    rendering: Res<RenderingDiagnosticsPanel>,
+    project_settings: Res<ProjectSettingsPanel>,
+) {
+    if exits.read().next().is_none() {
+        return;
+    }
+    let Some(path) = session_path() else {
+        return;
+    };
+    let document = EditorSessionDocument {
+        schema_version: SESSION_SCHEMA_VERSION,
+        clean_shutdown: true,
+        project_root: workspace.root.clone(),
+        active_scene: scene_io
+            .active_path
+            .as_ref()
+            .map(|path| path.display().to_string()),
+        dock_layout: prefs.dock_layout.clone(),
+        hierarchy_expanded_paths: prefs.hierarchy_expanded_paths.clone(),
+        panels: SessionPanelState {
+            diagnostics: diagnostics.open,
+            brush_diagnostics: brush_diagnostics.open,
+            rendering: rendering.open,
+            project_settings: project_settings.open,
+        },
+        camera_bookmarks: bookmarks
+            .poses
+            .iter()
+            .map(|(scene, transform)| {
+                CameraBookmarkRecord::from_transform(scene.clone(), *transform)
+            })
+            .collect(),
+    };
+    if let Err(error) = write_session(&path, &document) {
+        warn!("Failed to persist clean editor shutdown: {error}");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn legacy_unversioned_session_migrates_to_v1() {
+        let legacy = r#"(
+            clean_shutdown: true,
+            project_root: "/project",
+            active_scene: Some("assets/levels/test.scn.ron"),
+        )"#;
+        let document: EditorSessionDocument = ron::from_str(legacy).unwrap();
+
+        let migrated = normalize_session(document).unwrap();
+
+        assert_eq!(migrated.schema_version, SESSION_SCHEMA_VERSION);
+        assert_eq!(migrated.project_root, "/project");
+    }
+
+    #[test]
+    fn newer_session_schema_is_rejected() {
+        let document = EditorSessionDocument {
+            schema_version: SESSION_SCHEMA_VERSION + 1,
+            ..default()
+        };
+
+        assert!(normalize_session(document)
+            .unwrap_err()
+            .contains("newer than supported"));
+    }
+
+    #[test]
+    fn invalid_camera_pose_is_removed_during_migration() {
+        let mut document = EditorSessionDocument::default();
+        document.camera_bookmarks.push(CameraBookmarkRecord {
+            scene: "scene".to_string(),
+            translation: [f32::NAN, 0.0, 0.0],
+            rotation: [0.0, 0.0, 0.0, 1.0],
+            scale: [1.0; 3],
+        });
+
+        assert!(normalize_session(document)
+            .unwrap()
+            .camera_bookmarks
+            .is_empty());
+    }
+
+    #[test]
+    fn serialized_session_contains_only_allowlisted_metadata() {
+        let document = EditorSessionDocument {
+            project_root: "/project".to_string(),
+            active_scene: Some("assets/levels/test.scn.ron".to_string()),
+            ..default()
+        };
+        let text = ron::ser::to_string(&document).unwrap();
+
+        assert!(text.contains("active_scene"));
+        for forbidden in ["scene_contents", "credential", "token", "environment"] {
+            assert!(!text.to_ascii_lowercase().contains(forbidden));
+        }
+    }
+}
diff --git a/crates/editor/src/project/settings_ui.rs b/crates/editor/src/project/settings_ui.rs
index 80b0ee9..2c02b3b 100644
--- a/crates/editor/src/project/settings_ui.rs
+++ b/crates/editor/src/project/settings_ui.rs
@@ -210,6 +210,97 @@ fn draw_project_settings_form(
         );
     });
 
+    ui.collapsing("Audio Buses", |ui| {
+        let bus_ids: Vec<String> = draft.audio.buses.iter().map(|bus| bus.id.clone()).collect();
+        let mut remove_bus = None;
+        for (index, bus) in draft.audio.buses.iter_mut().enumerate() {
+            egui::Frame::new()
+                .fill(egui::Color32::from_rgb(24, 26, 29))
+                .stroke(egui::Stroke::new(1.0, egui::Color32::from_rgb(53, 57, 63)))
+                .corner_radius(4.0)
+                .inner_margin(8.0)
+                .show(ui, |ui| {
+                    ui.horizontal(|ui| {
+                        ui.strong(&bus.label);
+                        ui.small(
+                            egui::RichText::new(format!("[{}]", bus.id))
+                                .color(egui::Color32::from_rgb(139, 146, 156)),
+                        );
+                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                            let required = matches!(
+                                bus.id.as_str(),
+                                settings::AUDIO_BUS_MASTER_ID
+                                    | settings::AUDIO_BUS_MUSIC_ID
+                                    | settings::AUDIO_BUS_SFX_ID
+                            );
+                            if ui
+                                .add_enabled(!required, egui::Button::new("Remove"))
+                                .clicked()
+                            {
+                                remove_bus = Some(index);
+                            }
+                        });
+                    });
+                    ui.horizontal_wrapped(|ui| {
+                        ui.label("Name");
+                        ui.add_sized([140.0, 20.0], egui::TextEdit::singleline(&mut bus.label));
+                        ui.checkbox(&mut bus.muted, "Mute");
+                    });
+                    ui.add(
+                        egui::Slider::new(
+                            &mut bus.gain_db,
+                            settings::AUDIO_GAIN_DB_MIN..=settings::AUDIO_GAIN_DB_MAX,
+                        )
+                        .text("Gain")
+                        .suffix(" dB"),
+                    );
+                    if bus.id != settings::AUDIO_BUS_MASTER_ID {
+                        let parent_label = bus
+                            .parent
+                            .as_deref()
+                            .and_then(|parent| bus_ids.iter().find(|id| id.as_str() == parent))
+                            .map(String::as_str)
+                            .unwrap_or("None");
+                        egui::ComboBox::from_id_salt(("audio_bus_parent", index))
+                            .selected_text(parent_label)
+                            .show_ui(ui, |ui| {
+                                for candidate in &bus_ids {
+                                    if candidate != &bus.id {
+                                        ui.selectable_value(
+                                            &mut bus.parent,
+                                            Some(candidate.clone()),
+                                            candidate,
+                                        );
+                                    }
+                                }
+                            });
+                    }
+                });
+            ui.add_space(4.0);
+        }
+        if let Some(index) = remove_bus {
+            draft.audio.buses.remove(index);
+        }
+        if ui.button("Add Bus").clicked() {
+            let mut suffix = 1usize;
+            let id = loop {
+                let candidate = format!("bus_{suffix}");
+                if draft.audio.bus(&candidate).is_none() {
+                    break candidate;
+                }
+                suffix += 1;
+            };
+            draft.audio.buses.push(settings::AudioBusSettings::new(
+                id,
+                "New Bus",
+                Some(settings::AUDIO_BUS_MASTER_ID),
+            ));
+        }
+        if let Err(error) = draft.audio.validate() {
+            ui.colored_label(egui::Color32::from_rgb(235, 105, 105), error.to_string());
+        }
+    });
+
     ui.separator();
     ui.heading("Physics");
     ui.add(egui::Slider::new(&mut draft.physics.walk_speed, 1.0..=15.0).text("Walk speed"));
@@ -231,11 +322,18 @@ fn draw_project_settings_form(
     );
 
     ui.separator();
-    if ui.button("Apply").clicked() {
+    let settings_valid = draft.audio.validate().is_ok();
+    if ui
+        .add_enabled(settings_valid, egui::Button::new("Apply"))
+        .clicked()
+    {
         commit_project_settings(world, draft);
         *io_dirty = true;
     }
-    if ui.button("Save to disk").clicked() {
+    if ui
+        .add_enabled(settings_valid, egui::Button::new("Save to disk"))
+        .clicked()
+    {
         commit_project_settings(world, draft);
         let settings = world.resource::<ProjectSettings>().clone();
         let mut io = world.resource_mut::<ProjectSettingsIo>();
diff --git a/crates/editor/src/scene/mod.rs b/crates/editor/src/scene/mod.rs
index 072cad3..66e13f2 100644
--- a/crates/editor/src/scene/mod.rs
+++ b/crates/editor/src/scene/mod.rs
@@ -1,5 +1,6 @@
 //! Scene I/O, schema validation, and viewport render-target setup.
 
+pub(crate) mod recovery;
 pub mod scene_io;
 pub mod scene_schema;
 pub mod scene_view;
diff --git a/crates/editor/src/scene/recovery.rs b/crates/editor/src/scene/recovery.rs
new file mode 100644
index 0000000..01d0c7f
--- /dev/null
+++ b/crates/editor/src/scene/recovery.rs
@@ -0,0 +1,328 @@
+//! Transactional scene persistence and user-local recovery snapshot storage.
+
+use std::fs::{self, File, OpenOptions};
+use std::hash::Hasher;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+const STATE_DIR: &str = "blacksite-editor";
+const RECOVERY_DIR: &str = "recovery";
+
+pub(crate) fn atomic_write(path: &Path, bytes: &[u8]) -> Result<(), String> {
+    atomic_write_with_pre_rename(path, bytes, || Ok(()))
+}
+
+fn atomic_write_with_pre_rename(
+    path: &Path,
+    bytes: &[u8],
+    before_rename: impl FnOnce() -> Result<(), String>,
+) -> Result<(), String> {
+    let parent = path
+        .parent()
+        .filter(|parent| !parent.as_os_str().is_empty())
+        .unwrap_or_else(|| Path::new("."));
+    fs::create_dir_all(parent)
+        .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+
+    let file_name = path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("scene");
+    let nonce = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let temporary = parent.join(format!(".{file_name}.tmp-{}-{nonce}", std::process::id()));
+
+    let result = (|| {
+        let mut file = OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&temporary)
+            .map_err(|error| format!("could not create {}: {error}", temporary.display()))?;
+        file.write_all(bytes)
+            .map_err(|error| format!("could not write {}: {error}", temporary.display()))?;
+        file.sync_all()
+            .map_err(|error| format!("could not sync {}: {error}", temporary.display()))?;
+        before_rename()?;
+        fs::rename(&temporary, path).map_err(|error| {
+            format!(
+                "could not replace {} with {}: {error}",
+                path.display(),
+                temporary.display()
+            )
+        })?;
+        sync_parent_directory(parent);
+        Ok(())
+    })();
+
+    if result.is_err() {
+        let _ = fs::remove_file(&temporary);
+    }
+    result
+}
+
+#[cfg(unix)]
+fn sync_parent_directory(parent: &Path) {
+    if let Ok(directory) = File::open(parent) {
+        let _ = directory.sync_all();
+    }
+}
+
+#[cfg(not(unix))]
+fn sync_parent_directory(_parent: &Path) {}
+
+pub(crate) fn default_state_root() -> Option<PathBuf> {
+    if let Some(path) = std::env::var_os("XDG_STATE_HOME") {
+        return Some(PathBuf::from(path).join(STATE_DIR));
+    }
+    std::env::var_os("HOME")
+        .map(PathBuf::from)
+        .map(|home| home.join(".local/state").join(STATE_DIR))
+}
+
+pub(crate) fn write_recovery_snapshot(
+    state_root: &Path,
+    project_root: &Path,
+    scene_path: &Path,
+    bytes: &[u8],
+    max_generations: usize,
+) -> Result<PathBuf, String> {
+    let directory = recovery_directory(state_root, project_root, scene_path);
+    fs::create_dir_all(&directory)
+        .map_err(|error| format!("could not create {}: {error}", directory.display()))?;
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis();
+    let snapshot = directory.join(format!(
+        "recovery-{timestamp:020}-{}.scn.ron",
+        std::process::id()
+    ));
+    atomic_write(&snapshot, bytes)?;
+    prune_recovery_generations(&directory, max_generations.max(1))?;
+    Ok(snapshot)
+}
+
+pub(crate) fn latest_recovery_snapshot(
+    state_root: &Path,
+    project_root: &Path,
+    scene_path: &Path,
+) -> Option<PathBuf> {
+    let directory = recovery_directory(state_root, project_root, scene_path);
+    let source_modified = fs::metadata(scene_path)
+        .and_then(|metadata| metadata.modified())
+        .unwrap_or(UNIX_EPOCH);
+    recovery_files(&directory)
+        .into_iter()
+        .filter(|path| {
+            fs::metadata(path)
+                .and_then(|metadata| metadata.modified())
+                .is_ok_and(|modified| modified > source_modified)
+        })
+        .max_by_key(|path| path.file_name().map(|name| name.to_os_string()))
+}
+
+pub(crate) fn discard_recovery_snapshots(
+    state_root: &Path,
+    project_root: &Path,
+    scene_path: &Path,
+) -> Result<(), String> {
+    let directory = recovery_directory(state_root, project_root, scene_path);
+    if !directory.exists() {
+        return Ok(());
+    }
+    fs::remove_dir_all(&directory)
+        .map_err(|error| format!("could not remove {}: {error}", directory.display()))
+}
+
+fn recovery_directory(state_root: &Path, project_root: &Path, scene_path: &Path) -> PathBuf {
+    state_root
+        .join(RECOVERY_DIR)
+        .join(stable_path_hash(project_root))
+        .join(stable_path_hash(scene_path))
+}
+
+fn stable_path_hash(path: &Path) -> String {
+    let normalized = path.to_string_lossy().replace('\\', "/");
+    let mut hasher = Fnv1a64::default();
+    hasher.write(normalized.as_bytes());
+    format!("{:016x}", hasher.finish())
+}
+
+fn prune_recovery_generations(directory: &Path, max_generations: usize) -> Result<(), String> {
+    let mut files = recovery_files(directory);
+    files.sort_by_key(|path| path.file_name().map(|name| name.to_os_string()));
+    let remove_count = files.len().saturating_sub(max_generations);
+    for path in files.into_iter().take(remove_count) {
+        fs::remove_file(&path)
+            .map_err(|error| format!("could not prune {}: {error}", path.display()))?;
+    }
+    Ok(())
+}
+
+fn recovery_files(directory: &Path) -> Vec<PathBuf> {
+    let Ok(entries) = fs::read_dir(directory) else {
+        return Vec::new();
+    };
+    entries
+        .filter_map(Result::ok)
+        .map(|entry| entry.path())
+        .filter(|path| {
+            path.file_name()
+                .and_then(|name| name.to_str())
+                .is_some_and(|name| name.starts_with("recovery-") && name.ends_with(".scn.ron"))
+        })
+        .collect()
+}
+
+#[derive(Default)]
+struct Fnv1a64(u64);
+
+impl Hasher for Fnv1a64 {
+    fn finish(&self) -> u64 {
+        if self.0 == 0 {
+            0xcbf29ce484222325
+        } else {
+            self.0
+        }
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        let mut hash = self.finish();
+        for byte in bytes {
+            hash ^= u64::from(*byte);
+            hash = hash.wrapping_mul(0x100000001b3);
+        }
+        self.0 = hash;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn temp_directory(label: &str) -> PathBuf {
+        std::env::temp_dir().join(format!("blacksite-{label}-{}", uuid::Uuid::new_v4()))
+    }
+
+    #[test]
+    fn atomic_write_replaces_content_without_leaving_temporary_files() {
+        let root = temp_directory("atomic-write");
+        let path = root.join("scene.scn.ron");
+        fs::create_dir_all(&root).unwrap();
+        fs::write(&path, b"old").unwrap();
+
+        atomic_write(&path, b"new scene").unwrap();
+
+        assert_eq!(fs::read(&path).unwrap(), b"new scene");
+        assert_eq!(fs::read_dir(&root).unwrap().count(), 1);
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn interrupted_atomic_write_preserves_the_last_authored_scene() {
+        let root = temp_directory("atomic-interruption");
+        let path = root.join("scene.scn.ron");
+        fs::create_dir_all(&root).unwrap();
+        fs::write(&path, b"last known good scene").unwrap();
+
+        let result = atomic_write_with_pre_rename(&path, b"partial replacement", || {
+            Err("simulated interruption before rename".to_string())
+        });
+
+        assert_eq!(result.unwrap_err(), "simulated interruption before rename");
+        assert_eq!(fs::read(&path).unwrap(), b"last known good scene");
+        assert_eq!(fs::read_dir(&root).unwrap().count(), 1);
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn recovery_paths_are_stable_and_scene_specific() {
+        let state = Path::new("/state");
+        let project = Path::new("/project");
+        let first = recovery_directory(state, project, Path::new("assets/levels/a.scn.ron"));
+        let repeated = recovery_directory(state, project, Path::new("assets/levels/a.scn.ron"));
+        let second = recovery_directory(state, project, Path::new("assets/levels/b.scn.ron"));
+
+        assert_eq!(first, repeated);
+        assert_ne!(first, second);
+        assert!(first.starts_with("/state/recovery"));
+    }
+
+    #[test]
+    fn newer_recovery_generation_is_discovered_for_authored_scene() {
+        let root = temp_directory("recovery-discovery");
+        let project = Path::new("/project");
+        let scene = root.join("assets/levels/test.scn.ron");
+        fs::create_dir_all(scene.parent().unwrap()).unwrap();
+        fs::write(&scene, b"authored").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(10));
+
+        let snapshot = write_recovery_snapshot(&root, project, &scene, b"recovered", 5).unwrap();
+
+        assert_eq!(
+            latest_recovery_snapshot(&root, project, &scene),
+            Some(snapshot)
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn recovery_generations_are_bounded() {
+        let root = temp_directory("recovery-prune");
+        let project = Path::new("/project");
+        let scene = Path::new("assets/levels/test.scn.ron");
+        let directory = recovery_directory(&root, project, scene);
+        fs::create_dir_all(&directory).unwrap();
+        for index in 0..5 {
+            fs::write(
+                directory.join(format!("recovery-{index:020}-1.scn.ron")),
+                index.to_string(),
+            )
+            .unwrap();
+        }
+
+        prune_recovery_generations(&directory, 3).unwrap();
+
+        let mut names: Vec<String> = recovery_files(&directory)
+            .into_iter()
+            .map(|path| path.file_name().unwrap().to_string_lossy().into_owned())
+            .collect();
+        names.sort();
+        assert_eq!(
+            names,
+            vec![
+                "recovery-00000000000000000002-1.scn.ron",
+                "recovery-00000000000000000003-1.scn.ron",
+                "recovery-00000000000000000004-1.scn.ron",
+            ]
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn discard_removes_all_scene_generations() {
+        let root = temp_directory("recovery-discard");
+        let project = Path::new("/project");
+        let scene = Path::new("assets/levels/test.scn.ron");
+        let directory = recovery_directory(&root, project, scene);
+        fs::create_dir_all(&directory).unwrap();
+        fs::write(
+            directory.join("recovery-00000000000000000001-1.scn.ron"),
+            b"one",
+        )
+        .unwrap();
+        fs::write(
+            directory.join("recovery-00000000000000000002-1.scn.ron"),
+            b"two",
+        )
+        .unwrap();
+
+        discard_recovery_snapshots(&root, project, scene).unwrap();
+
+        assert!(!directory.exists());
+        fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/crates/editor/src/scene/scene_io.rs b/crates/editor/src/scene/scene_io.rs
index 138aed8..bbf60af 100644
--- a/crates/editor/src/scene/scene_io.rs
+++ b/crates/editor/src/scene/scene_io.rs
@@ -1,30 +1,37 @@
-use std::path::{Path, PathBuf};
+use std::collections::{HashSet, VecDeque};
+use std::path::{Component, Path, PathBuf};
 
 use bevy::ecs::entity::EntityHashMap;
 use bevy::ecs::system::SystemState;
 use bevy::prelude::*;
 use bevy::window::PrimaryWindow;
 use bevy::world_serialization::serde::WorldDeserializer;
-use bevy::world_serialization::{DynamicWorld, DynamicWorldBuilder};
+use bevy::world_serialization::{DynamicWorld, DynamicWorldBuilder, WorldInstance};
 use scene::{document::SceneDocument, strip_schema_version, validate_level_text};
 use serde::de::DeserializeSeed;
 use shared::{
-    flush_level_object_hydration, infer_actor_kind, strip_hydrated_entity, validate_actor, ActorId,
-    ActorKind, ActorName, ActorValidationError, BrushDesc, ColliderDesc, EditorVisibility,
-    HierarchySiblingIndex, InspectorOrder, LevelObject, LightDesc, MaterialDesc, MaterialOverride,
-    ModelRef, ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabInstance,
-    PrefabRef, Primitive, RigidBodyDesc, StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
+    infer_actor_kind, validate_actor, ActorId, ActorKind, ActorName, ActorValidationError,
+    AnimationControllerDesc, AudioListenerDesc, AudioSourceDesc, BrushDesc, ColliderDesc,
+    EditorVisibility, HierarchySiblingIndex, HydratedPrefabMember, HydratedPrefabReady,
+    InspectorOrder, LevelObject, LightDesc, MaterialDesc, MaterialOverride, ModelRef,
+    ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabHydrationBlocked,
+    PrefabInstance, PrefabRef, Primitive, RigidBodyDesc, SceneComposition, StaticMeshRenderer,
+    TeamSpawn, TriggerVolume, WeaponSpawn,
 };
 
-use crate::assets::{import_external_assets, EditorAssets};
+use crate::assets::{import_external_assets, EditorAssets, IMPORTABLE_ASSET_EXTENSIONS};
 use crate::history::{clear_level_objects, snapshot_entity, EditorHistory};
+use crate::scene::recovery::{
+    atomic_write, default_state_root, discard_recovery_snapshots, latest_recovery_snapshot,
+    write_recovery_snapshot,
+};
 use crate::selection::SelectedEntity;
 use crate::ui::hierarchy_ops::{
     backfill_missing_editor_visibility, backfill_missing_sibling_indices,
 };
 use crate::ui::UiState;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum SceneIoRequest {
     New,
     Open,
@@ -33,7 +40,35 @@ pub enum SceneIoRequest {
     ImportAssets,
     ExportSelection,
     SaveSelectionAsPrefab,
+    SwitchProject,
+    RestoreRecovery,
+    SaveRecoveryCopyAs,
+    DiscardRecovery,
     OpenRecent(usize),
+    OpenPath(PathBuf),
+    SwitchTab(usize),
+    CloseTab(usize),
+    ReloadComposition,
+}
+
+#[derive(Debug, Clone)]
+pub struct SceneTab {
+    pub id: u64,
+    pub path: Option<PathBuf>,
+    pub dirty: bool,
+    snapshot: String,
+    recovery_snapshot: Option<PathBuf>,
+}
+
+impl SceneTab {
+    pub fn label(&self) -> String {
+        self.path
+            .as_deref()
+            .and_then(Path::file_name)
+            .and_then(|name| name.to_str())
+            .unwrap_or("Untitled")
+            .to_string()
+    }
 }
 
 #[derive(Resource, Debug)]
@@ -45,17 +80,53 @@ pub struct SceneIo {
     pub dirty: bool,
     /// When set, the next I/O request needs unsaved-changes confirmation.
     pub pending_request: Option<SceneIoRequest>,
+    /// Newest recovery snapshot that is newer than the active authored scene.
+    pub recovery_snapshot: Option<PathBuf>,
+    /// Bounded in-session audit trail for scene persistence and recovery operations.
+    pub events: VecDeque<SceneIoEvent>,
+    pub tabs: Vec<SceneTab>,
+    pub active_tab: usize,
+    next_event_id: u64,
+    next_tab_id: u64,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SceneIoEventSeverity {
+    Info,
+    Error,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SceneIoEvent {
+    pub id: u64,
+    pub severity: SceneIoEventSeverity,
+    pub message: String,
+}
+
+const MAX_SCENE_IO_EVENTS: usize = 32;
+
 impl Default for SceneIo {
     fn default() -> Self {
+        let active_path = None;
         Self {
-            active_path: Some(PathBuf::from("assets/levels/editor_scene.scn.ron")),
+            active_path: active_path.clone(),
             recent_paths: Vec::new(),
             request: None,
             status: "Ready".to_string(),
             dirty: false,
             pending_request: None,
+            recovery_snapshot: None,
+            events: VecDeque::new(),
+            tabs: vec![SceneTab {
+                id: 1,
+                path: active_path,
+                dirty: false,
+                snapshot: String::new(),
+                recovery_snapshot: None,
+            }],
+            active_tab: 0,
+            next_event_id: 1,
+            next_tab_id: 2,
         }
     }
 }
@@ -63,10 +134,12 @@ impl Default for SceneIo {
 impl SceneIo {
     pub fn mark_dirty(&mut self) {
         self.dirty = true;
+        self.sync_active_tab_metadata();
     }
 
     pub fn mark_clean(&mut self) {
         self.dirty = false;
+        self.sync_active_tab_metadata();
     }
 
     pub fn active_path_label(&self) -> String {
@@ -75,19 +148,84 @@ impl SceneIo {
             .map(|path| path.display().to_string())
             .unwrap_or_else(|| "Unsaved scene".to_string())
     }
+
+    pub fn set_status(&mut self, status: impl Into<String>) {
+        let message = status.into();
+        let normalized = message.to_ascii_lowercase();
+        let severity = if normalized.contains("failed")
+            || normalized.contains("error")
+            || normalized.contains("could not")
+        {
+            SceneIoEventSeverity::Error
+        } else {
+            SceneIoEventSeverity::Info
+        };
+        self.status.clone_from(&message);
+        self.events.push_back(SceneIoEvent {
+            id: self.next_event_id,
+            severity,
+            message,
+        });
+        self.next_event_id = self.next_event_id.saturating_add(1);
+        while self.events.len() > MAX_SCENE_IO_EVENTS {
+            self.events.pop_front();
+        }
+    }
+
+    pub fn clear_events(&mut self) {
+        self.events.clear();
+    }
+
+    pub fn has_unsaved_tabs(&self) -> bool {
+        self.dirty || self.tabs.iter().any(|tab| tab.dirty)
+    }
+
+    fn sync_active_tab_metadata(&mut self) {
+        if let Some(tab) = self.tabs.get_mut(self.active_tab) {
+            tab.path.clone_from(&self.active_path);
+            tab.dirty = self.dirty;
+            tab.recovery_snapshot.clone_from(&self.recovery_snapshot);
+        }
+    }
+
+    fn allocate_tab_id(&mut self) -> u64 {
+        let id = self.next_tab_id;
+        self.next_tab_id = self.next_tab_id.saturating_add(1);
+        id
+    }
 }
 
 #[derive(Component)]
 struct LoadedSceneRoot;
 
+/// Runtime-only ownership marker for entities hydrated from composed subscenes.
+#[derive(Component, Debug, Clone)]
+pub struct ComposedSceneMember {
+    pub reference_id: String,
+    pub scene_id: String,
+    pub source_path: PathBuf,
+}
+
+#[derive(Resource, Default)]
+struct RecoveryClock {
+    elapsed_secs: f32,
+}
+
 pub struct SceneIoPlugin;
 
 impl Plugin for SceneIoPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<SceneIo>()
+            .init_resource::<SceneComposition>()
+            .init_resource::<RecoveryClock>()
             .add_systems(
                 Update,
-                (process_scene_io_requests, update_window_title).chain(),
+                (
+                    process_scene_io_requests,
+                    tick_scene_recovery,
+                    update_window_title,
+                )
+                    .chain(),
             )
             .add_systems(PostStartup, load_startup_scene);
     }
@@ -109,11 +247,27 @@ fn load_startup_scene(world: &mut World) {
             world.resource_mut::<SceneIo>().mark_clean();
             remember_path(world, path.clone());
             world.resource_mut::<EditorHistory>().clear();
-            world.resource_mut::<SceneIo>().status = format!("Loaded {}", path.display());
+            refresh_recovery_notice(world, &path);
+            if let Err(error) = capture_active_tab(world) {
+                warn!("Failed to capture startup scene tab: {error}");
+            }
+            let recovery = world.resource::<SceneIo>().recovery_snapshot.clone();
+            let status = recovery.map_or_else(
+                || format!("Loaded {}", path.display()),
+                |snapshot| {
+                    format!(
+                        "Loaded {}; newer recovery available: {}",
+                        path.display(),
+                        snapshot.display()
+                    )
+                },
+            );
+            world.resource_mut::<SceneIo>().set_status(status);
         }
         Err(err) => {
-            world.resource_mut::<SceneIo>().status =
-                format!("Startup scene load failed: {err}; using generated starter arena");
+            world.resource_mut::<SceneIo>().set_status(format!(
+                "Startup scene load failed: {err}; using generated starter arena"
+            ));
         }
     }
 }
@@ -125,7 +279,7 @@ fn process_scene_io_requests(world: &mut World) {
             pending
         } else {
             match io.request.take() {
-                Some(req) if io.dirty && needs_dirty_confirm(&req) => {
+                Some(req) if io.has_unsaved_tabs() && needs_dirty_confirm(&req) => {
                     io.pending_request = Some(req);
                     return;
                 }
@@ -135,42 +289,45 @@ fn process_scene_io_requests(world: &mut World) {
         }
     };
 
-    if world.resource::<SceneIo>().dirty && needs_dirty_confirm(&request) {
+    if world.resource::<SceneIo>().has_unsaved_tabs() && needs_dirty_confirm(&request) {
         match confirm_discard_or_save() {
             DirtyConfirm::Save => {
-                let save_status = save_active_or_prompt(world);
+                let save_status = save_all_tabs(world);
                 if save_status.starts_with("Save failed") || save_status.ends_with("cancelled") {
-                    world.resource_mut::<SceneIo>().status = save_status;
+                    world.resource_mut::<SceneIo>().set_status(save_status);
                     return;
                 }
             }
             DirtyConfirm::Discard => {}
             DirtyConfirm::Cancel => {
-                world.resource_mut::<SceneIo>().status = "Operation cancelled".to_string();
+                world
+                    .resource_mut::<SceneIo>()
+                    .set_status("Operation cancelled");
                 return;
             }
         }
     }
 
     let status = match request {
-        SceneIoRequest::New => {
-            clear_loaded_scene_roots(world);
-            clear_level_objects(world);
-            world.resource_mut::<SceneIo>().active_path = None;
-            world.resource_mut::<SceneIo>().mark_clean();
-            world.resource_mut::<EditorHistory>().clear();
-            "Created a new empty level".to_string()
-        }
+        SceneIoRequest::New => new_scene_tab(world),
         SceneIoRequest::Save => save_active_or_prompt(world),
         SceneIoRequest::SaveAs => save_with_dialog(world),
         SceneIoRequest::Open => open_with_dialog(world),
         SceneIoRequest::ImportAssets => import_with_dialog(world),
         SceneIoRequest::ExportSelection => export_selection_with_dialog(world),
         SceneIoRequest::SaveSelectionAsPrefab => save_selection_as_prefab(world),
+        SceneIoRequest::SwitchProject => switch_project(world),
+        SceneIoRequest::RestoreRecovery => restore_recovery(world),
+        SceneIoRequest::SaveRecoveryCopyAs => save_recovery_copy_with_dialog(world),
+        SceneIoRequest::DiscardRecovery => discard_recovery(world),
         SceneIoRequest::OpenRecent(index) => open_recent(world, index),
+        SceneIoRequest::OpenPath(path) => open_path(world, path),
+        SceneIoRequest::SwitchTab(index) => switch_scene_tab(world, index),
+        SceneIoRequest::CloseTab(index) => close_scene_tab(world, index),
+        SceneIoRequest::ReloadComposition => reload_active_composition(world),
     };
 
-    world.resource_mut::<SceneIo>().status = status;
+    world.resource_mut::<SceneIo>().set_status(status);
 }
 
 enum DirtyConfirm {
@@ -180,10 +337,17 @@ enum DirtyConfirm {
 }
 
 fn needs_dirty_confirm(request: &SceneIoRequest) -> bool {
-    matches!(
-        request,
-        SceneIoRequest::New | SceneIoRequest::Open | SceneIoRequest::OpenRecent(_)
-    )
+    matches!(request, SceneIoRequest::SwitchProject)
+}
+
+fn switch_project(world: &mut World) -> String {
+    match crate::launcher::spawn_project_launcher_process() {
+        Ok(()) => {
+            world.write_message(AppExit::Success);
+            "Opening Blacksite Project Browser".to_string()
+        }
+        Err(error) => format!("Switch project failed: {error}"),
+    }
 }
 
 fn confirm_discard_or_save() -> DirtyConfirm {
@@ -206,20 +370,292 @@ fn open_recent(world: &mut World, index: usize) -> String {
     let Some(path) = path else {
         return "Recent scene not found".to_string();
     };
+    open_path(world, path)
+}
+
+fn open_path(world: &mut World, path: PathBuf) -> String {
+    if let Some(index) = world
+        .resource::<SceneIo>()
+        .tabs
+        .iter()
+        .position(|tab| tab.path.as_ref() == Some(&path))
+    {
+        return switch_scene_tab(world, index);
+    }
+    if let Err(error) = capture_active_tab(world) {
+        return format!("Open failed: could not preserve active scene: {error}");
+    }
     match load_level(world, &path) {
         Ok(()) => {
-            world.resource_mut::<SceneIo>().active_path = Some(path.clone());
-            world.resource_mut::<SceneIo>().mark_clean();
+            let id = world.resource_mut::<SceneIo>().allocate_tab_id();
+            {
+                let mut io = world.resource_mut::<SceneIo>();
+                io.tabs.push(SceneTab {
+                    id,
+                    path: Some(path.clone()),
+                    dirty: false,
+                    snapshot: String::new(),
+                    recovery_snapshot: None,
+                });
+                io.active_tab = io.tabs.len() - 1;
+                io.active_path = Some(path.clone());
+                io.recovery_snapshot = None;
+                io.mark_clean();
+            }
             remember_path(world, path.clone());
             world.resource_mut::<EditorHistory>().clear();
+            refresh_recovery_notice(world, &path);
+            if let Err(error) = capture_active_tab(world) {
+                warn!("Failed to capture opened scene tab: {error}");
+            }
             format!("Loading {}", path.display())
         }
         Err(err) => format!("Open failed: {err}"),
     }
 }
 
+fn new_scene_tab(world: &mut World) -> String {
+    if let Err(error) = capture_active_tab(world) {
+        return format!("New scene failed: could not preserve active scene: {error}");
+    }
+    clear_scene_world(world);
+    world.insert_resource(SceneComposition {
+        scene_id: uuid::Uuid::new_v4().to_string(),
+        subscenes: Vec::new(),
+    });
+    let id = world.resource_mut::<SceneIo>().allocate_tab_id();
+    {
+        let mut io = world.resource_mut::<SceneIo>();
+        io.tabs.push(SceneTab {
+            id,
+            path: None,
+            dirty: false,
+            snapshot: String::new(),
+            recovery_snapshot: None,
+        });
+        io.active_tab = io.tabs.len() - 1;
+        io.active_path = None;
+        io.recovery_snapshot = None;
+        io.mark_clean();
+    }
+    world.resource_mut::<EditorHistory>().clear();
+    if let Err(error) = capture_active_tab(world) {
+        return format!("New scene failed: {error}");
+    }
+    "Created a new empty scene tab".to_string()
+}
+
+fn capture_active_tab(world: &mut World) -> Result<(), String> {
+    if world.resource::<SceneIo>().tabs.is_empty() {
+        return Ok(());
+    }
+    ensure_scene_composition_identity(world);
+    let text = serialize_active_scene(world)?;
+    let (active_tab, active_path, dirty, recovery_snapshot) = {
+        let io = world.resource::<SceneIo>();
+        (
+            io.active_tab,
+            io.active_path.clone(),
+            io.dirty,
+            io.recovery_snapshot.clone(),
+        )
+    };
+    let mut io = world.resource_mut::<SceneIo>();
+    let Some(tab) = io.tabs.get_mut(active_tab) else {
+        return Err(format!("active scene tab {active_tab} is missing"));
+    };
+    tab.path = active_path;
+    tab.dirty = dirty;
+    tab.snapshot = text;
+    tab.recovery_snapshot = recovery_snapshot;
+    Ok(())
+}
+
+fn switch_scene_tab(world: &mut World, index: usize) -> String {
+    let current = world.resource::<SceneIo>().active_tab;
+    if index == current {
+        return "Scene tab is already active".to_string();
+    }
+    if index >= world.resource::<SceneIo>().tabs.len() {
+        return "Scene tab not found".to_string();
+    }
+    if let Err(error) = capture_active_tab(world) {
+        return format!("Scene switch failed: could not preserve active scene: {error}");
+    }
+    let target = world.resource::<SceneIo>().tabs[index].clone();
+    if target.snapshot.is_empty() {
+        return "Scene switch failed: target tab has no recoverable snapshot".to_string();
+    }
+    if let Err(error) = load_level_text(world, target.path.as_deref(), &target.snapshot) {
+        return format!("Scene switch failed: {error}");
+    }
+    {
+        let mut io = world.resource_mut::<SceneIo>();
+        io.active_tab = index;
+        io.active_path = target.path.clone();
+        io.dirty = target.dirty;
+        io.recovery_snapshot = target.recovery_snapshot.clone();
+        io.sync_active_tab_metadata();
+    }
+    world.resource_mut::<EditorHistory>().clear();
+    format!("Activated scene tab {}", target.label())
+}
+
+fn close_scene_tab(world: &mut World, index: usize) -> String {
+    if index >= world.resource::<SceneIo>().tabs.len() {
+        return "Scene tab not found".to_string();
+    }
+    if index != world.resource::<SceneIo>().active_tab {
+        let status = switch_scene_tab(world, index);
+        if status.starts_with("Scene switch failed") {
+            return status;
+        }
+    }
+
+    if world.resource::<SceneIo>().dirty {
+        match confirm_close_scene() {
+            DirtyConfirm::Save => {
+                let status = save_active_or_prompt(world);
+                if status.starts_with("Save failed") || status.ends_with("cancelled") {
+                    return status;
+                }
+            }
+            DirtyConfirm::Discard => {}
+            DirtyConfirm::Cancel => return "Close scene cancelled".to_string(),
+        }
+    }
+
+    if world.resource::<SceneIo>().tabs.len() == 1 {
+        clear_scene_world(world);
+        world.insert_resource(SceneComposition {
+            scene_id: uuid::Uuid::new_v4().to_string(),
+            subscenes: Vec::new(),
+        });
+        {
+            let mut io = world.resource_mut::<SceneIo>();
+            let id = io.allocate_tab_id();
+            io.tabs = vec![SceneTab {
+                id,
+                path: None,
+                dirty: false,
+                snapshot: String::new(),
+                recovery_snapshot: None,
+            }];
+            io.active_tab = 0;
+            io.active_path = None;
+            io.recovery_snapshot = None;
+            io.mark_clean();
+        }
+        world.resource_mut::<EditorHistory>().clear();
+        let _ = capture_active_tab(world);
+        return "Closed scene; created an empty scene tab".to_string();
+    }
+
+    let closing = world.resource::<SceneIo>().active_tab;
+    let target_index = if closing + 1 < world.resource::<SceneIo>().tabs.len() {
+        closing + 1
+    } else {
+        closing - 1
+    };
+    let target = world.resource::<SceneIo>().tabs[target_index].clone();
+    if let Err(error) = load_level_text(world, target.path.as_deref(), &target.snapshot) {
+        return format!("Close scene failed: {error}");
+    }
+    {
+        let mut io = world.resource_mut::<SceneIo>();
+        io.tabs.remove(closing);
+        io.active_tab = if target_index > closing {
+            target_index - 1
+        } else {
+            target_index
+        };
+        io.active_path = target.path.clone();
+        io.dirty = target.dirty;
+        io.recovery_snapshot = target.recovery_snapshot;
+        io.sync_active_tab_metadata();
+    }
+    world.resource_mut::<EditorHistory>().clear();
+    "Closed scene tab".to_string()
+}
+
+fn reload_active_composition(world: &mut World) -> String {
+    if let Err(error) = capture_active_tab(world) {
+        return format!("Composition reload failed: {error}");
+    }
+    let target = world.resource::<SceneIo>().tabs[world.resource::<SceneIo>().active_tab].clone();
+    if let Err(error) = load_level_text(world, target.path.as_deref(), &target.snapshot) {
+        return format!("Composition reload failed: {error}");
+    }
+    {
+        let mut io = world.resource_mut::<SceneIo>();
+        io.active_path = target.path;
+        io.dirty = target.dirty;
+        io.recovery_snapshot = target.recovery_snapshot;
+        io.sync_active_tab_metadata();
+    }
+    world.resource_mut::<EditorHistory>().clear();
+    "Reloaded active scene composition".to_string()
+}
+
+fn confirm_close_scene() -> DirtyConfirm {
+    use rfd::{MessageButtons, MessageDialog, MessageLevel};
+    match MessageDialog::new()
+        .set_title("Close Scene")
+        .set_description("This scene tab has unsaved changes. Save before closing it?")
+        .set_level(MessageLevel::Warning)
+        .set_buttons(MessageButtons::YesNoCancel)
+        .show()
+    {
+        rfd::MessageDialogResult::Yes => DirtyConfirm::Save,
+        rfd::MessageDialogResult::No => DirtyConfirm::Discard,
+        _ => DirtyConfirm::Cancel,
+    }
+}
+
+fn save_all_tabs(world: &mut World) -> String {
+    let original_id = world.resource::<SceneIo>().tabs[world.resource::<SceneIo>().active_tab].id;
+    let dirty_ids: Vec<u64> = world
+        .resource::<SceneIo>()
+        .tabs
+        .iter()
+        .filter(|tab| tab.dirty)
+        .map(|tab| tab.id)
+        .collect();
+    for id in dirty_ids {
+        let Some(index) = world
+            .resource::<SceneIo>()
+            .tabs
+            .iter()
+            .position(|tab| tab.id == id)
+        else {
+            continue;
+        };
+        if index != world.resource::<SceneIo>().active_tab {
+            let status = switch_scene_tab(world, index);
+            if status.starts_with("Scene switch failed") {
+                return format!("Save failed: {status}");
+            }
+        }
+        let status = save_active_or_prompt(world);
+        if status.starts_with("Save failed") || status.ends_with("cancelled") {
+            return status;
+        }
+    }
+    if let Some(index) = world
+        .resource::<SceneIo>()
+        .tabs
+        .iter()
+        .position(|tab| tab.id == original_id)
+    {
+        if index != world.resource::<SceneIo>().active_tab {
+            let _ = switch_scene_tab(world, index);
+        }
+    }
+    "Saved all modified scene tabs".to_string()
+}
+
 fn save_selection_as_prefab(world: &mut World) -> String {
-    let selection: Vec<Entity> = world
+    let selected_roots: Vec<Entity> = world
         .get_resource::<UiState>()
         .map(|ui| {
             ui.selected_entities
@@ -232,6 +668,7 @@ fn save_selection_as_prefab(world: &mut World) -> String {
                 .collect()
         })
         .unwrap_or_default();
+    let selection = expand_authored_selection(world, &selected_roots);
     if selection.is_empty() {
         return "Select level objects to save as prefab".to_string();
     }
@@ -245,7 +682,11 @@ fn save_selection_as_prefab(world: &mut World) -> String {
         return "Save prefab cancelled".to_string();
     };
 
-    match save_entities(world, &path, selection) {
+    if ensure_unique_actor_ids(world, &selection) > 0 {
+        world.resource_mut::<SceneIo>().mark_dirty();
+    }
+
+    match save_prefab_entities(world, &path, selection) {
         Ok(count) => {
             world.resource_mut::<EditorAssets>().refresh();
             format!(
@@ -257,6 +698,111 @@ fn save_selection_as_prefab(world: &mut World) -> String {
     }
 }
 
+fn ensure_unique_actor_ids(world: &mut World, entities: &[Entity]) -> usize {
+    let selected: HashSet<Entity> = entities.iter().copied().collect();
+    let mut occupied: HashSet<String> = world
+        .query_filtered::<(
+            Entity,
+            &ActorId,
+            Has<HydratedPrefabMember>,
+            Has<ComposedSceneMember>,
+        ), With<LevelObject>>()
+        .iter(world)
+        .filter(|(entity, id, hydrated, composed)| {
+            !selected.contains(entity) && !id.0.trim().is_empty() && !hydrated && !composed
+        })
+        .map(|(_, id, _, _)| id.0.clone())
+        .collect();
+    let mut changed = 0;
+    for entity in entities {
+        let current = world
+            .get::<ActorId>(*entity)
+            .map(|id| id.0.trim().to_string())
+            .filter(|id| !id.is_empty());
+        if current
+            .as_ref()
+            .is_some_and(|actor_id| occupied.insert(actor_id.clone()))
+        {
+            continue;
+        }
+        let actor_id = loop {
+            let candidate = uuid::Uuid::new_v4().to_string();
+            if occupied.insert(candidate.clone()) {
+                break candidate;
+            }
+        };
+        if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
+            entity_mut.insert(ActorId::new(actor_id));
+            changed += 1;
+        }
+    }
+    changed
+}
+
+fn expand_authored_selection(world: &World, roots: &[Entity]) -> Vec<Entity> {
+    let mut selected = HashSet::new();
+    let mut stack = roots.to_vec();
+    while let Some(entity) = stack.pop() {
+        if !world
+            .get_entity(entity)
+            .is_ok_and(|entity_ref| entity_ref.contains::<LevelObject>())
+            || world.get::<HydratedPrefabMember>(entity).is_some()
+            || world.get::<ComposedSceneMember>(entity).is_some()
+            || !selected.insert(entity)
+        {
+            continue;
+        }
+        if let Some(children) = world.get::<Children>(entity) {
+            stack.extend(children.iter());
+        }
+    }
+    let mut selected: Vec<_> = selected.into_iter().collect();
+    selected.sort_by_key(|entity| entity.to_bits());
+    selected
+}
+
+fn save_prefab_entities(
+    world: &mut World,
+    path: &Path,
+    entities: Vec<Entity>,
+) -> Result<usize, String> {
+    let count = entities.len();
+    let original_actor_ids: Vec<_> = entities
+        .iter()
+        .map(|entity| (*entity, world.get::<ActorId>(*entity).cloned()))
+        .collect();
+    let repaired = ensure_unique_actor_ids(world, &entities);
+    let result = (|| {
+        let text = serialize_standalone_entities(world, entities)?;
+        let project_root = PathBuf::from(
+            world
+                .resource::<crate::project_io::ProjectWorkspace>()
+                .root
+                .clone(),
+        );
+        scene::validate_prefab_graph_text(&text, path, &project_root)?;
+        atomic_write(path, text.as_bytes())?;
+        Ok(count)
+    })();
+    if result.is_err() {
+        for (entity, actor_id) in original_actor_ids {
+            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+                match actor_id {
+                    Some(actor_id) => {
+                        entity_mut.insert(actor_id);
+                    }
+                    None => {
+                        entity_mut.remove::<ActorId>();
+                    }
+                }
+            }
+        }
+    } else if repaired > 0 {
+        world.resource_mut::<SceneIo>().mark_dirty();
+    }
+    result
+}
+
 /// Save helper for play-mode and other cross-module callers.
 pub fn save_active_or_prompt_world(world: &mut World) -> String {
     save_active_or_prompt(world)
@@ -269,6 +815,7 @@ fn save_active_or_prompt(world: &mut World) -> String {
             Ok(count) => {
                 world.resource_mut::<SceneIo>().mark_clean();
                 remember_path(world, path.clone());
+                retire_scene_recovery(world, &path);
                 format!("Saved {count} level entities to {}", path.display())
             }
             Err(err) => format!("Save failed: {err}"),
@@ -292,6 +839,7 @@ fn save_with_dialog(world: &mut World) -> String {
             world.resource_mut::<SceneIo>().active_path = Some(path.clone());
             world.resource_mut::<SceneIo>().mark_clean();
             remember_path(world, path.clone());
+            retire_scene_recovery(world, &path);
             format!("Saved {count} level entities to {}", path.display())
         }
         Err(err) => format!("Save failed: {err}"),
@@ -307,24 +855,12 @@ fn open_with_dialog(world: &mut World) -> String {
         return "Open cancelled".to_string();
     };
 
-    match load_level(world, &path) {
-        Ok(()) => {
-            world.resource_mut::<SceneIo>().active_path = Some(path.clone());
-            world.resource_mut::<SceneIo>().mark_clean();
-            remember_path(world, path.clone());
-            world.resource_mut::<EditorHistory>().clear();
-            format!("Loading {}", path.display())
-        }
-        Err(err) => format!("Open failed: {err}"),
-    }
+    open_path(world, path)
 }
 
 fn import_with_dialog(world: &mut World) -> String {
     let Some(paths) = rfd::FileDialog::new()
-        .add_filter(
-            "Editor assets",
-            &["gltf", "glb", "fbx", "png", "jpg", "jpeg", "webp", "ktx2"],
-        )
+        .add_filter("Editor assets", IMPORTABLE_ASSET_EXTENSIONS)
         .pick_files()
     else {
         return "Import cancelled".to_string();
@@ -356,7 +892,7 @@ fn export_selection_with_dialog(world: &mut World) -> String {
         return "Export cancelled".to_string();
     };
 
-    match save_entities(world, &path, vec![entity]) {
+    match save_standalone_entities(world, &path, vec![entity]) {
         Ok(count) => format!("Exported {count} selected entity to {}", path.display()),
         Err(err) => format!("Export failed: {err}"),
     }
@@ -372,12 +908,57 @@ fn clear_loaded_scene_roots(world: &mut World) {
     }
 }
 
+fn clear_scene_world(world: &mut World) {
+    clear_loaded_scene_roots(world);
+    clear_level_objects(world);
+    if let Some(mut hierarchy) =
+        world.get_resource_mut::<crate::ui::hierarchy_state::HierarchyPanelState>()
+    {
+        hierarchy.locked.clear();
+    }
+    if let Some(mut ui) = world.get_resource_mut::<UiState>() {
+        ui.selected_entities.clear();
+    }
+    if let Some(mut selected) = world.get_resource_mut::<SelectedEntity>() {
+        selected.0 = None;
+    }
+}
+
 fn save_level(world: &mut World, path: &Path) -> Result<usize, String> {
-    let mut query = world
-        .try_query_filtered::<Entity, With<LevelObject>>()
-        .ok_or_else(|| "could not create LevelObject query".to_string())?;
-    let entities: Vec<Entity> = query.iter(world).collect();
-    save_entities(world, path, entities)
+    let entities = authored_scene_entities(world);
+    if is_prefab_document(path) {
+        save_prefab_entities(world, path, entities)
+    } else {
+        save_entities(world, path, entities)
+    }
+}
+
+fn serialize_active_scene(world: &mut World) -> Result<String, String> {
+    let entities = authored_scene_entities(world);
+    if world
+        .resource::<SceneIo>()
+        .active_path
+        .as_deref()
+        .is_some_and(is_prefab_document)
+    {
+        serialize_standalone_entities(world, entities)
+    } else {
+        serialize_entities(world, entities)
+    }
+}
+
+pub(crate) fn is_prefab_document(path: &Path) -> bool {
+    let normalized = path.to_string_lossy().replace('\\', "/");
+    normalized.starts_with("assets/prefabs/") || normalized.contains("/assets/prefabs/")
+}
+
+fn authored_scene_entities(world: &mut World) -> Vec<Entity> {
+    let mut query = world.query_filtered::<Entity, (
+        With<LevelObject>,
+        Without<ComposedSceneMember>,
+        Without<HydratedPrefabMember>,
+    )>();
+    query.iter(world).collect()
 }
 
 fn format_actor_validation(err: ActorValidationError) -> String {
@@ -437,6 +1018,69 @@ fn format_actor_validation(err: ActorValidationError) -> String {
         ActorValidationError::LightHasStaticMeshRenderer => {
             "Save failed: Light actor cannot have StaticMeshRenderer".into()
         }
+        ActorValidationError::AudioSourceMissingDesc => {
+            "Save failed: AudioSource actor requires AudioSourceDesc".into()
+        }
+        ActorValidationError::AudioSourceMissingClip => {
+            "Save failed: audio source requires an assigned clip".into()
+        }
+        ActorValidationError::AudioSourceInvalidClipReference => {
+            "Save failed: audio source clip reference is unresolved or not an audio clip".into()
+        }
+        ActorValidationError::AudioSourceInvalidGain => {
+            "Save failed: audio source gain is outside the supported dB range".into()
+        }
+        ActorValidationError::AudioSourceInvalidPitch => {
+            "Save failed: audio source pitch must be positive and finite".into()
+        }
+        ActorValidationError::AudioSourceInvalidSpatialBlend => {
+            "Save failed: audio source spatial blend must be between 0 and 1".into()
+        }
+        ActorValidationError::AudioSourceInvalidAttenuation => {
+            "Save failed: audio source attenuation distances or rolloff are invalid".into()
+        }
+        ActorValidationError::AudioSourceMissingBus => {
+            "Save failed: audio source requires a bus ID".into()
+        }
+        ActorValidationError::AudioListenerMissingDesc => {
+            "Save failed: AudioListener actor requires AudioListenerDesc".into()
+        }
+        ActorValidationError::AudioListenerInvalidEarGap => {
+            "Save failed: audio listener ear gap must be positive and finite".into()
+        }
+        ActorValidationError::AnimationControllerMissingModelRef => {
+            "Save failed: animation controller requires ModelRef on the same actor".into()
+        }
+        ActorValidationError::AnimationControllerMissingSkeleton => {
+            "Save failed: animation controller requires an assigned skeleton".into()
+        }
+        ActorValidationError::AnimationControllerInvalidSkeletonReference => {
+            "Save failed: animation controller skeleton reference is unresolved or invalid".into()
+        }
+        ActorValidationError::AnimationControllerEmptyStateId => {
+            "Save failed: animation controller state IDs cannot be empty".into()
+        }
+        ActorValidationError::AnimationControllerDuplicateStateId => {
+            "Save failed: animation controller state IDs must be unique".into()
+        }
+        ActorValidationError::AnimationControllerInvalidClipReference => {
+            "Save failed: animation states require resolved glTF/GLB clip references".into()
+        }
+        ActorValidationError::AnimationControllerInvalidStateSpeed => {
+            "Save failed: animation state speed must be finite and nonzero".into()
+        }
+        ActorValidationError::AnimationControllerInvalidStateRange => {
+            "Save failed: animation state playback range is invalid".into()
+        }
+        ActorValidationError::AnimationControllerInvalidCrossfade => {
+            "Save failed: animation controller crossfade must be finite and non-negative".into()
+        }
+        ActorValidationError::AnimationControllerMissingDefaultState => {
+            "Save failed: animation controller requires a default state".into()
+        }
+        ActorValidationError::AnimationControllerUnknownDefaultState => {
+            "Save failed: animation controller default state does not exist".into()
+        }
         ActorValidationError::PostProcessVolumeMissingDesc => {
             "Save failed: PostProcessVolume actor requires PostProcessVolumeDesc".into()
         }
@@ -454,7 +1098,43 @@ fn format_actor_validation(err: ActorValidationError) -> String {
 
 fn save_entities(world: &mut World, path: &Path, entities: Vec<Entity>) -> Result<usize, String> {
     let count = entities.len();
+    let text = serialize_entities(world, entities)?;
+    atomic_write(path, text.as_bytes())?;
+    Ok(count)
+}
 
+fn save_standalone_entities(
+    world: &mut World,
+    path: &Path,
+    entities: Vec<Entity>,
+) -> Result<usize, String> {
+    let count = entities.len();
+    let text = serialize_standalone_entities(world, entities)?;
+    atomic_write(path, text.as_bytes())?;
+    Ok(count)
+}
+
+fn serialize_entities(world: &mut World, entities: Vec<Entity>) -> Result<String, String> {
+    serialize_entities_inner_with_resources(world, entities, true)
+}
+
+#[cfg(test)]
+fn serialize_entities_inner(world: &mut World, entities: Vec<Entity>) -> Result<String, String> {
+    serialize_entities_inner_with_resources(world, entities, true)
+}
+
+fn serialize_standalone_entities(
+    world: &mut World,
+    entities: Vec<Entity>,
+) -> Result<String, String> {
+    serialize_entities_inner_with_resources(world, entities, false)
+}
+
+fn serialize_entities_inner_with_resources(
+    world: &mut World,
+    entities: Vec<Entity>,
+    include_scene_resources: bool,
+) -> Result<String, String> {
     for entity in &entities {
         let entity_ref = world.entity(*entity);
         if let Err(err) = validate_actor(entity_ref) {
@@ -462,63 +1142,362 @@ fn save_entities(world: &mut World, path: &Path, entities: Vec<Entity>) -> Resul
         }
     }
 
-    for entity in &entities {
-        if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
-            strip_hydrated_entity(&mut entity_mut);
+    let entity_set: HashSet<Entity> = entities.iter().copied().collect();
+    let detached_parents: Vec<(Entity, Entity, Transform)> = if include_scene_resources {
+        Vec::new()
+    } else {
+        entities
+            .iter()
+            .filter_map(|entity| {
+                world
+                    .get::<ChildOf>(*entity)
+                    .map(ChildOf::parent)
+                    .filter(|parent| !entity_set.contains(parent))
+                    .and_then(|parent| {
+                        computed_world_transform(world, *entity)
+                            .map(|world_transform| (*entity, parent, world_transform))
+                    })
+            })
+            .collect()
+    };
+    let original_local_transforms: Vec<(Entity, Transform)> = detached_parents
+        .iter()
+        .filter_map(|(entity, _, _)| {
+            world
+                .get::<Transform>(*entity)
+                .copied()
+                .map(|transform| (*entity, transform))
+        })
+        .collect();
+    for (entity, _, world_transform) in &detached_parents {
+        world
+            .entity_mut(*entity)
+            .remove::<ChildOf>()
+            .insert(*world_transform);
+    }
+
+    let result = (|| {
+        let ron = {
+            let registry = world.resource::<AppTypeRegistry>().read();
+            let builder = DynamicWorldBuilder::from_world(world, &registry)
+                .deny_all()
+                .allow_component::<Name>()
+                .allow_component::<Transform>()
+                .allow_component::<ChildOf>()
+                .allow_component::<LevelObject>()
+                .allow_component::<ActorId>()
+                .allow_component::<ActorName>()
+                .allow_component::<ActorKind>()
+                .allow_component::<InspectorOrder>()
+                .allow_component::<Primitive>()
+                .allow_component::<BrushDesc>()
+                .allow_component::<StaticMeshRenderer>()
+                .allow_component::<MaterialDesc>()
+                .allow_component::<MaterialOverride>()
+                .allow_component::<RigidBodyDesc>()
+                .allow_component::<ColliderDesc>()
+                .allow_component::<PhysicsBody>()
+                .allow_component::<LightDesc>()
+                .allow_component::<AnimationControllerDesc>()
+                .allow_component::<AudioSourceDesc>()
+                .allow_component::<AudioListenerDesc>()
+                .allow_component::<PlayerSpawn>()
+                .allow_component::<ModelRef>()
+                .allow_component::<PrefabRef>()
+                .allow_component::<PrefabInstance>()
+                .allow_component::<WeaponSpawn>()
+                .allow_component::<TriggerVolume>()
+                .allow_component::<PostProcessVolumeDesc>()
+                .allow_component::<TeamSpawn>()
+                .allow_component::<ObjectiveMarker>()
+                .allow_component::<HierarchySiblingIndex>()
+                .allow_component::<EditorVisibility>()
+                .extract_entities(entities.into_iter());
+            let scene = if include_scene_resources {
+                builder
+                    .allow_resource::<SceneComposition>()
+                    .extract_resources()
+                    .remove_empty_entities()
+                    .build()
+            } else {
+                builder.remove_empty_entities().build()
+            };
+
+            scene
+                .serialize(&registry)
+                .map_err(|err| format!("could not serialize scene: {err}"))?
+        };
+
+        let document = SceneDocument::from_ron_text(&ron)?;
+        document.to_ron_text()
+    })();
+    for (entity, transform) in original_local_transforms {
+        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.insert(transform);
         }
     }
+    for (entity, parent, _) in detached_parents {
+        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.insert(ChildOf(parent));
+        }
+    }
+    result
+}
 
-    let ron = {
-        let registry = world.resource::<AppTypeRegistry>().read();
-        let scene = DynamicWorldBuilder::from_world(world, &registry)
-            .deny_all()
-            .allow_component::<Name>()
-            .allow_component::<Transform>()
-            .allow_component::<ChildOf>()
-            .allow_component::<LevelObject>()
-            .allow_component::<ActorId>()
-            .allow_component::<ActorName>()
-            .allow_component::<ActorKind>()
-            .allow_component::<InspectorOrder>()
-            .allow_component::<Primitive>()
-            .allow_component::<BrushDesc>()
-            .allow_component::<StaticMeshRenderer>()
-            .allow_component::<MaterialDesc>()
-            .allow_component::<MaterialOverride>()
-            .allow_component::<RigidBodyDesc>()
-            .allow_component::<ColliderDesc>()
-            .allow_component::<PhysicsBody>()
-            .allow_component::<LightDesc>()
-            .allow_component::<PlayerSpawn>()
-            .allow_component::<ModelRef>()
-            .allow_component::<PrefabRef>()
-            .allow_component::<PrefabInstance>()
-            .allow_component::<WeaponSpawn>()
-            .allow_component::<TriggerVolume>()
-            .allow_component::<PostProcessVolumeDesc>()
-            .allow_component::<TeamSpawn>()
-            .allow_component::<ObjectiveMarker>()
-            .allow_component::<HierarchySiblingIndex>()
-            .allow_component::<EditorVisibility>()
-            .extract_entities(entities.into_iter())
-            .remove_empty_entities()
-            .build();
+fn computed_world_transform(world: &World, entity: Entity) -> Option<Transform> {
+    let mut chain = Vec::new();
+    let mut current = entity;
+    let mut visited = HashSet::new();
+    while visited.insert(current) {
+        chain.push(*world.get::<Transform>(current)?);
+        let Some(parent) = world.get::<ChildOf>(current).map(ChildOf::parent) else {
+            break;
+        };
+        current = parent;
+    }
+    if world.get::<ChildOf>(current).is_some() {
+        return None;
+    }
+    let mut chain = chain.into_iter().rev();
+    let root = chain.next()?;
+    Some(
+        chain
+            .fold(GlobalTransform::from(root), |global, local| {
+                global.mul_transform(local)
+            })
+            .compute_transform(),
+    )
+}
 
-        scene
-            .serialize(&registry)
-            .map_err(|err| format!("could not serialize scene: {err}"))?
+fn tick_scene_recovery(world: &mut World) {
+    let (enabled, interval_secs, max_generations) = {
+        let prefs = world.resource::<crate::project_io::UserPreferences>();
+        (
+            prefs.scene_autosave_enabled,
+            recovery_interval_secs(prefs),
+            prefs.scene_recovery_generations.max(1),
+        )
+    };
+    if !enabled {
+        return;
+    }
+
+    let dirty = world.resource::<SceneIo>().has_unsaved_tabs();
+    let delta = world.resource::<Time>().delta_secs();
+    let should_snapshot = {
+        let mut clock = world.resource_mut::<RecoveryClock>();
+        if !dirty {
+            clock.elapsed_secs = 0.0;
+            return;
+        }
+        clock.elapsed_secs += delta;
+        if clock.elapsed_secs < interval_secs {
+            false
+        } else {
+            clock.elapsed_secs = 0.0;
+            true
+        }
+    };
+    if !should_snapshot {
+        return;
+    }
+
+    let status = match save_dirty_tab_recoveries(world, max_generations) {
+        Ok(0) => "Recovery skipped: modified tabs are unsaved".to_string(),
+        Ok(1) => "Recovery snapshot saved for 1 scene tab".to_string(),
+        Ok(count) => format!("Recovery snapshots saved for {count} scene tabs"),
+        Err(error) => format!("Recovery snapshot failed: {error}"),
+    };
+    world.resource_mut::<SceneIo>().set_status(status);
+}
+
+fn recovery_interval_secs(prefs: &crate::project_io::UserPreferences) -> f32 {
+    std::env::var("BLACKSITE_RECOVERY_INTERVAL_SECS")
+        .ok()
+        .and_then(|value| value.parse::<f32>().ok())
+        .filter(|value| value.is_finite() && *value >= 1.0)
+        .unwrap_or_else(|| prefs.scene_autosave_interval_secs.max(15) as f32)
+}
+
+fn save_dirty_tab_recoveries(world: &mut World, max_generations: usize) -> Result<usize, String> {
+    capture_active_tab(world)?;
+    let state_root =
+        default_state_root().ok_or_else(|| "HOME and XDG_STATE_HOME are unset".to_string())?;
+    let project_root = PathBuf::from(
+        world
+            .resource::<crate::project_io::ProjectWorkspace>()
+            .root
+            .clone(),
+    );
+    let candidates = dirty_saved_tab_snapshots(world.resource::<SceneIo>());
+    let mut saved = Vec::with_capacity(candidates.len());
+    for (index, path, snapshot) in candidates {
+        let recovery = write_recovery_snapshot(
+            &state_root,
+            &project_root,
+            &path,
+            snapshot.as_bytes(),
+            max_generations,
+        )?;
+        saved.push((index, recovery));
+    }
+    let count = saved.len();
+    let mut io = world.resource_mut::<SceneIo>();
+    for (index, recovery) in saved {
+        if let Some(tab) = io.tabs.get_mut(index) {
+            tab.recovery_snapshot = Some(recovery.clone());
+        }
+        if io.active_tab == index {
+            io.recovery_snapshot = Some(recovery);
+        }
+    }
+    Ok(count)
+}
+
+fn dirty_saved_tab_snapshots(io: &SceneIo) -> Vec<(usize, PathBuf, String)> {
+    io.tabs
+        .iter()
+        .enumerate()
+        .filter_map(|(index, tab)| {
+            (tab.dirty && !tab.snapshot.is_empty())
+                .then(|| {
+                    tab.path
+                        .clone()
+                        .map(|path| (index, path, tab.snapshot.clone()))
+                })
+                .flatten()
+        })
+        .collect()
+}
+
+fn refresh_recovery_notice(world: &mut World, scene_path: &Path) {
+    let recovery = default_state_root().and_then(|state_root| {
+        let project_root = PathBuf::from(
+            world
+                .resource::<crate::project_io::ProjectWorkspace>()
+                .root
+                .clone(),
+        );
+        latest_recovery_snapshot(&state_root, &project_root, scene_path)
+    });
+    world.resource_mut::<SceneIo>().recovery_snapshot = recovery;
+}
+
+fn retire_scene_recovery(world: &mut World, scene_path: &Path) {
+    let Some(state_root) = default_state_root() else {
+        return;
+    };
+    let project_root = PathBuf::from(
+        world
+            .resource::<crate::project_io::ProjectWorkspace>()
+            .root
+            .clone(),
+    );
+    if let Err(error) = discard_recovery_snapshots(&state_root, &project_root, scene_path) {
+        warn!("Failed to retire scene recovery snapshots: {error}");
+    }
+    world.resource_mut::<SceneIo>().recovery_snapshot = None;
+}
+
+fn restore_recovery(world: &mut World) -> String {
+    let (active_path, snapshot) = {
+        let io = world.resource::<SceneIo>();
+        (io.active_path.clone(), io.recovery_snapshot.clone())
+    };
+    let Some(snapshot) = snapshot else {
+        return "No scene recovery snapshot is available".to_string();
+    };
+    match load_level(world, &snapshot) {
+        Ok(()) => {
+            mark_recovery_restored(&mut world.resource_mut::<SceneIo>(), active_path);
+            world.resource_mut::<EditorHistory>().clear();
+            format!(
+                "Restored recovery {}; save the scene to keep it or discard the snapshot",
+                snapshot.display()
+            )
+        }
+        Err(error) => format!("Recovery restore failed: {error}"),
+    }
+}
+
+fn save_recovery_copy_with_dialog(world: &mut World) -> String {
+    let (active_path, snapshot) = {
+        let io = world.resource::<SceneIo>();
+        (io.active_path.clone(), io.recovery_snapshot.clone())
+    };
+    let Some(snapshot) = snapshot else {
+        return "No scene recovery snapshot is available".to_string();
+    };
+    let directory = active_path
+        .as_deref()
+        .and_then(Path::parent)
+        .unwrap_or_else(|| Path::new("assets/levels"));
+    let file_name = active_path
+        .as_deref()
+        .and_then(Path::file_name)
+        .and_then(|name| name.to_str())
+        .and_then(|name| name.strip_suffix(".scn.ron"))
+        .map_or_else(
+            || "recovered_scene.scn.ron".to_string(),
+            |stem| format!("{stem}.recovered.scn.ron"),
+        );
+    let Some(destination) = rfd::FileDialog::new()
+        .set_directory(directory)
+        .add_filter("Bevy scene", &["scn.ron", "ron"])
+        .set_file_name(file_name)
+        .save_file()
+    else {
+        return "Save recovery copy cancelled".to_string();
     };
 
-    if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent)
-            .map_err(|err| format!("could not create {}: {err}", parent.display()))?;
+    match write_recovery_copy(&snapshot, &destination) {
+        Ok(()) => format!(
+            "Saved recovery copy {} from {}",
+            destination.display(),
+            snapshot.display()
+        ),
+        Err(error) => format!("Save recovery copy failed: {error}"),
     }
-    let document = SceneDocument::from_ron_text(&ron)?;
-    std::fs::write(path, document.to_ron_text()?)
-        .map_err(|err| format!("could not write {}: {err}", path.display()))?;
-    finalize_scene_load(world);
+}
 
-    Ok(count)
+fn write_recovery_copy(snapshot: &Path, destination: &Path) -> Result<(), String> {
+    let bytes = std::fs::read(snapshot)
+        .map_err(|error| format!("could not read {}: {error}", snapshot.display()))?;
+    atomic_write(destination, &bytes)
+}
+
+fn mark_recovery_restored(io: &mut SceneIo, active_path: Option<PathBuf>) {
+    io.active_path = active_path;
+    io.mark_dirty();
+}
+
+fn discard_recovery(world: &mut World) -> String {
+    let (scene_path, snapshot) = {
+        let io = world.resource::<SceneIo>();
+        (io.active_path.clone(), io.recovery_snapshot.clone())
+    };
+    let (Some(scene_path), Some(snapshot)) = (scene_path, snapshot) else {
+        return "No scene recovery snapshot is available".to_string();
+    };
+    let Some(state_root) = default_state_root() else {
+        return "Recovery discard failed: HOME and XDG_STATE_HOME are unset".to_string();
+    };
+    let project_root = PathBuf::from(
+        world
+            .resource::<crate::project_io::ProjectWorkspace>()
+            .root
+            .clone(),
+    );
+    match discard_recovery_snapshots(&state_root, &project_root, &scene_path) {
+        Ok(()) => {
+            world.resource_mut::<SceneIo>().recovery_snapshot = None;
+            format!(
+                "Discarded recovery generations including {}",
+                snapshot.display()
+            )
+        }
+        Err(error) => format!("Recovery discard failed: {error}"),
+    }
 }
 
 fn load_level(world: &mut World, path: &Path) -> Result<(), String> {
@@ -528,30 +1507,45 @@ fn load_level(world: &mut World, path: &Path) -> Result<(), String> {
 
     let text = std::fs::read_to_string(path)
         .map_err(|err| format!("could not read {}: {err}", path.display()))?;
-    validate_level_text(&text)?;
-    let document = SceneDocument::from_ron_text(&text)?;
+    load_level_text(world, Some(path), &text)
+}
+
+fn load_level_text(world: &mut World, path: Option<&Path>, text: &str) -> Result<(), String> {
+    validate_level_text(text)?;
+    let document = SceneDocument::from_ron_text(text)?;
+    if let Some(composition) = document.composition.as_ref() {
+        scene::validate_scene_composition(composition)?;
+    }
+    let project_root = PathBuf::from(
+        world
+            .resource::<crate::project_io::ProjectWorkspace>()
+            .root
+            .clone(),
+    )
+    .canonicalize()
+    .map_err(|error| format!("could not resolve project root: {error}"))?;
     let bevy_ron = strip_schema_version(document.normalized_ron())?;
+    let dynamic_scene = deserialize_dynamic_scene(world, &bevy_ron)?;
+    let composition = document
+        .composition
+        .unwrap_or_else(|| legacy_scene_composition(path));
+    preflight_subscenes(&composition, &project_root)?;
 
-    clear_loaded_scene_roots(world);
-    clear_level_objects(world);
-
-    let dynamic_scene: DynamicWorld = {
-        let registry = world.resource::<AppTypeRegistry>().read();
-        let mut asset_server = world.resource::<AssetServer>().clone();
-        let scene_deserializer = WorldDeserializer {
-            type_registry: &registry,
-            load_from_path: &mut asset_server,
-        };
-        let mut deserializer =
-            ron::de::Deserializer::from_str(&bevy_ron).map_err(|err| err.to_string())?;
-        scene_deserializer
-            .deserialize(&mut deserializer)
-            .map_err(|err| format!("could not deserialize scene: {err}"))?
-    };
+    clear_scene_world(world);
+    world.remove_resource::<SceneComposition>();
 
     dynamic_scene
         .write_to_world(world, &mut EntityHashMap::default())
         .map_err(|err| format!("could not spawn scene: {err}"))?;
+    if !world.contains_resource::<SceneComposition>() {
+        world.insert_resource(composition.clone());
+    }
+
+    let root_path = path.and_then(|path| path.canonicalize().ok());
+    let mut visiting = root_path.into_iter().collect::<Vec<_>>();
+    load_composed_subscenes(world, &composition, &project_root, &mut visiting, "", false)?;
+    upgrade_legacy_prefab_instances(world);
+    block_invalid_prefab_instances(world, &project_root);
 
     backfill_missing_actor_kinds(world);
     backfill_missing_sibling_indices(world);
@@ -567,9 +1561,210 @@ fn load_level(world: &mut World, path: &Path) -> Result<(), String> {
     Ok(())
 }
 
-fn finalize_scene_load(world: &mut World) {
-    flush_level_object_hydration(world);
+fn upgrade_legacy_prefab_instances(world: &mut World) -> usize {
+    let legacy: Vec<(Entity, String)> = world
+        .query_filtered::<(Entity, &PrefabRef), Without<PrefabInstance>>()
+        .iter(world)
+        .map(|(entity, prefab)| (entity, prefab.path.clone()))
+        .collect();
+    for (entity, path) in &legacy {
+        world
+            .entity_mut(*entity)
+            .insert(PrefabInstance::new(format!("legacy:{path}"), path.clone()));
+    }
+    legacy.len()
+}
 
+fn block_invalid_prefab_instances(world: &mut World, project_root: &Path) -> usize {
+    let instances: Vec<(Entity, PrefabInstance)> = world
+        .query::<(Entity, &PrefabInstance)>()
+        .iter(world)
+        .map(|(entity, instance)| (entity, instance.clone()))
+        .collect();
+    let mut blocked = 0;
+    for (entity, instance) in instances {
+        match scene::validate_prefab_graph(&project_root.join(&instance.source_path), project_root)
+        {
+            Ok(()) => {
+                world.entity_mut(entity).remove::<PrefabHydrationBlocked>();
+            }
+            Err(reason) => {
+                blocked += 1;
+                world
+                    .entity_mut(entity)
+                    .insert(PrefabHydrationBlocked { reason })
+                    .remove::<PrefabRef>()
+                    .remove::<HydratedPrefabReady>()
+                    .remove::<DynamicWorldRoot>()
+                    .remove::<WorldInstance>();
+            }
+        }
+    }
+    blocked
+}
+
+fn deserialize_dynamic_scene(world: &World, bevy_ron: &str) -> Result<DynamicWorld, String> {
+    let registry = world.resource::<AppTypeRegistry>().read();
+    let mut asset_server = world.resource::<AssetServer>().clone();
+    let scene_deserializer = WorldDeserializer {
+        type_registry: &registry,
+        load_from_path: &mut asset_server,
+    };
+    let mut deserializer =
+        ron::de::Deserializer::from_str(bevy_ron).map_err(|err| err.to_string())?;
+    scene_deserializer
+        .deserialize(&mut deserializer)
+        .map_err(|err| format!("could not deserialize scene: {err}"))
+}
+
+fn legacy_scene_composition(path: Option<&Path>) -> SceneComposition {
+    let scene_id = path.map_or_else(
+        || uuid::Uuid::new_v4().to_string(),
+        |path| format!("legacy:{}", path.to_string_lossy().replace('\\', "/")),
+    );
+    SceneComposition {
+        scene_id,
+        subscenes: Vec::new(),
+    }
+}
+
+fn ensure_scene_composition_identity(world: &mut World) {
+    if !world.contains_resource::<SceneComposition>() {
+        let path = world.resource::<SceneIo>().active_path.clone();
+        world.insert_resource(legacy_scene_composition(path.as_deref()));
+    }
+    if world
+        .resource::<SceneComposition>()
+        .scene_id
+        .trim()
+        .is_empty()
+    {
+        world.resource_mut::<SceneComposition>().scene_id = uuid::Uuid::new_v4().to_string();
+    }
+}
+
+fn preflight_subscenes(composition: &SceneComposition, project_root: &Path) -> Result<(), String> {
+    scene::validate_scene_composition(composition)?;
+    for reference in &composition.subscenes {
+        let target = resolve_subscene_path(project_root, &reference.path)?;
+        scene::validate_composition_graph(&target, project_root)?;
+    }
+    Ok(())
+}
+
+fn resolve_subscene_path(project_root: &Path, relative: &str) -> Result<PathBuf, String> {
+    let relative_path = Path::new(relative);
+    if relative_path.is_absolute()
+        || relative_path.components().any(|component| {
+            matches!(
+                component,
+                Component::ParentDir | Component::RootDir | Component::Prefix(_)
+            )
+        })
+    {
+        return Err(format!(
+            "subscene path `{relative}` escapes the project root"
+        ));
+    }
+    let target = project_root
+        .join(relative_path)
+        .canonicalize()
+        .map_err(|error| {
+            format!(
+                "missing subscene `{relative}` under {}: {error}",
+                project_root.display()
+            )
+        })?;
+    if !target.starts_with(project_root) {
+        return Err(format!(
+            "subscene path `{relative}` escapes the project root"
+        ));
+    }
+    Ok(target)
+}
+
+fn load_composed_subscenes(
+    world: &mut World,
+    composition: &SceneComposition,
+    project_root: &Path,
+    visiting: &mut Vec<PathBuf>,
+    reference_prefix: &str,
+    inherited_lock: bool,
+) -> Result<(), String> {
+    for reference in &composition.subscenes {
+        if !reference.visible {
+            continue;
+        }
+        let target = resolve_subscene_path(project_root, &reference.path)?;
+        if let Some(index) = visiting.iter().position(|path| path == &target) {
+            let mut cycle: Vec<String> = visiting[index..]
+                .iter()
+                .map(|path| {
+                    path.strip_prefix(project_root)
+                        .unwrap_or(path)
+                        .display()
+                        .to_string()
+                })
+                .collect();
+            cycle.push(reference.path.clone());
+            return Err(format!("cyclic subscene reference: {}", cycle.join(" -> ")));
+        }
+
+        let text = std::fs::read_to_string(&target)
+            .map_err(|error| format!("could not read {}: {error}", target.display()))?;
+        let document = SceneDocument::from_ron_text(&text)?;
+        let scene_id = document
+            .composition
+            .as_ref()
+            .map(|composition| composition.scene_id.clone())
+            .unwrap_or_else(|| legacy_scene_composition(Some(&target)).scene_id);
+        let bevy_ron = strip_schema_version(document.normalized_ron())?;
+        let mut dynamic_scene = deserialize_dynamic_scene(world, &bevy_ron)?;
+        dynamic_scene.resources.clear();
+        let mut entity_map = EntityHashMap::default();
+        dynamic_scene
+            .write_to_world(world, &mut entity_map)
+            .map_err(|error| format!("could not spawn subscene {}: {error}", target.display()))?;
+
+        let reference_id = if reference_prefix.is_empty() {
+            reference.id.clone()
+        } else {
+            format!("{reference_prefix}/{}", reference.id)
+        };
+        let locked = inherited_lock || reference.locked;
+        let loaded_entities: Vec<Entity> = entity_map.values().copied().collect();
+        for entity in &loaded_entities {
+            world.entity_mut(*entity).insert(ComposedSceneMember {
+                reference_id: reference_id.clone(),
+                scene_id: scene_id.clone(),
+                source_path: target.clone(),
+            });
+        }
+        if locked {
+            if let Some(mut hierarchy) =
+                world.get_resource_mut::<crate::ui::hierarchy_state::HierarchyPanelState>()
+            {
+                hierarchy.locked.extend(loaded_entities.iter().copied());
+            }
+        }
+
+        if let Some(child_composition) = document.composition {
+            visiting.push(target);
+            load_composed_subscenes(
+                world,
+                &child_composition,
+                project_root,
+                visiting,
+                &reference_id,
+                locked,
+            )?;
+            visiting.pop();
+        }
+    }
+    Ok(())
+}
+
+fn finalize_scene_load(world: &mut World) {
     let rendering = world
         .resource::<settings::ProjectSettings>()
         .rendering
@@ -648,3 +1843,910 @@ fn update_window_title(
 
     window.title = crate::project_io::window_title(&io, &workspace, &settings);
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::any::TypeId;
+
+    use bevy::asset::{AssetPath, LoadFromPath, UntypedHandle};
+    use bevy::world_serialization::{
+        DynamicWorldRoot, WorldInstanceSpawner, WorldSerializationPlugin,
+    };
+
+    struct NoAssetLoads;
+
+    impl LoadFromPath for NoAssetLoads {
+        fn load_from_path_erased(
+            &mut self,
+            _type_id: TypeId,
+            _path: AssetPath<'static>,
+        ) -> UntypedHandle {
+            panic!("hierarchy fixture does not contain asset handles")
+        }
+    }
+
+    #[test]
+    fn restored_recovery_remains_available_until_save_or_discard() {
+        let authored = PathBuf::from("assets/levels/authored.scn.ron");
+        let snapshot = PathBuf::from("/state/recovery/snapshot.scn.ron");
+        let mut io = SceneIo {
+            active_path: None,
+            recovery_snapshot: Some(snapshot.clone()),
+            ..default()
+        };
+
+        mark_recovery_restored(&mut io, Some(authored.clone()));
+
+        assert_eq!(io.active_path, Some(authored));
+        assert_eq!(io.recovery_snapshot, Some(snapshot));
+        assert!(io.dirty);
+    }
+
+    #[test]
+    fn active_tab_tracks_path_and_dirty_state() {
+        let mut io = SceneIo::default();
+        assert_eq!(io.tabs.len(), 1);
+        assert!(!io.tabs[0].dirty);
+
+        io.active_path = Some(PathBuf::from("assets/levels/arena.scn.ron"));
+        io.mark_dirty();
+
+        assert!(io.has_unsaved_tabs());
+        assert!(io.tabs[0].dirty);
+        assert_eq!(
+            io.tabs[0].path.as_deref(),
+            Some(Path::new("assets/levels/arena.scn.ron"))
+        );
+        io.mark_clean();
+        assert!(!io.has_unsaved_tabs());
+
+        io.tabs.push(SceneTab {
+            id: 2,
+            path: Some(PathBuf::from("assets/levels/lighting.scn.ron")),
+            dirty: true,
+            snapshot: "dirty inactive tab".to_string(),
+            recovery_snapshot: None,
+        });
+        assert!(
+            io.has_unsaved_tabs(),
+            "inactive modified tabs must participate in save/recovery prompts"
+        );
+        let candidates = dirty_saved_tab_snapshots(&io);
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].0, 1);
+        assert_eq!(
+            candidates[0].1,
+            PathBuf::from("assets/levels/lighting.scn.ron")
+        );
+    }
+
+    #[test]
+    fn composition_edits_participate_in_undo_and_redo() {
+        let mut app = App::new();
+        app.init_resource::<SceneIo>()
+            .init_resource::<EditorHistory>()
+            .insert_resource(SceneComposition {
+                scene_id: "main".to_string(),
+                subscenes: Vec::new(),
+            });
+        let changed = SceneComposition {
+            scene_id: "main".to_string(),
+            subscenes: vec![shared::SubsceneReference {
+                id: "lighting".to_string(),
+                path: "assets/levels/lighting.scn.ron".to_string(),
+                visible: true,
+                locked: true,
+            }],
+        };
+
+        crate::history::set_scene_composition_with_history(app.world_mut(), changed.clone());
+        assert_eq!(app.world().resource::<EditorHistory>().undo_depth(), 1);
+        assert_eq!(app.world().resource::<SceneComposition>(), &changed);
+
+        crate::history::apply_command_undo(app.world_mut());
+        assert!(app
+            .world()
+            .resource::<SceneComposition>()
+            .subscenes
+            .is_empty());
+        crate::history::apply_command_redo(app.world_mut());
+        assert_eq!(app.world().resource::<SceneComposition>(), &changed);
+    }
+
+    #[test]
+    fn scene_finalize_defers_hydration_to_the_registered_update_pipeline() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin::default())
+            .add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
+            .init_asset::<Mesh>()
+            .add_plugins(shared::SharedTypesPlugin);
+        app.world_mut()
+            .insert_resource(settings::ProjectSettings::default());
+
+        let actor = app
+            .world_mut()
+            .spawn((
+                LevelObject,
+                BrushDesc::default(),
+                ColliderDesc::static_cuboid(Vec3::ONE),
+            ))
+            .id();
+
+        finalize_scene_load(app.world_mut());
+        assert!(
+            app.world().get::<Children>(actor).is_none(),
+            "scene finalization must not create collider children ahead of Update"
+        );
+
+        app.update();
+        let first_child = app
+            .world()
+            .get::<Children>(actor)
+            .and_then(|children| children.first().copied())
+            .expect("the registered hydration pipeline should create one brush child");
+        assert!(app
+            .world()
+            .get::<avian3d::prelude::ColliderConstructor>(first_child)
+            .is_some());
+
+        app.update();
+        assert_eq!(
+            app.world()
+                .get::<Children>(actor)
+                .and_then(|children| children.first().copied()),
+            Some(first_child),
+            "unchanged authoring data must not replace freshly hydrated collider children"
+        );
+    }
+
+    #[test]
+    fn scene_serialization_persists_composition_without_composed_members() {
+        let mut app = App::new();
+        app.register_type::<Name>()
+            .register_type::<Transform>()
+            .register_type::<LevelObject>()
+            .register_type::<ActorKind>()
+            .register_type::<SceneComposition>()
+            .register_type::<shared::SubsceneReference>();
+        let world = app.world_mut();
+        world.insert_resource(SceneComposition {
+            scene_id: "main".to_string(),
+            subscenes: vec![shared::SubsceneReference {
+                id: "geometry".to_string(),
+                path: "assets/levels/geometry.scn.ron".to_string(),
+                visible: true,
+                locked: true,
+            }],
+        });
+        let owned = world
+            .spawn((
+                Name::new("Owned"),
+                Transform::default(),
+                LevelObject,
+                ActorKind::Empty,
+            ))
+            .id();
+        world.spawn((
+            Name::new("Composed"),
+            Transform::default(),
+            LevelObject,
+            ActorKind::Empty,
+            ComposedSceneMember {
+                reference_id: "geometry".to_string(),
+                scene_id: "geometry-scene".to_string(),
+                source_path: PathBuf::from("assets/levels/geometry.scn.ron"),
+            },
+        ));
+
+        let text = serialize_entities_inner(world, vec![owned]).unwrap();
+        let document = SceneDocument::from_ron_text(&text).unwrap();
+
+        assert_eq!(document.entities.len(), 1);
+        assert_eq!(document.entities[0].name.as_deref(), Some("Owned"));
+        assert_eq!(
+            document
+                .composition
+                .as_ref()
+                .map(|value| value.scene_id.as_str()),
+            Some("main")
+        );
+        assert_eq!(document.composition.unwrap().subscenes.len(), 1);
+
+        let standalone =
+            serialize_entities_inner_with_resources(world, vec![owned], false).unwrap();
+        let standalone = SceneDocument::from_ron_text(&standalone).unwrap();
+        assert!(
+            standalone.composition.is_none(),
+            "prefabs and selection exports must not carry level resources"
+        );
+    }
+
+    #[test]
+    fn audio_authoring_round_trip_excludes_runtime_playback_components() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(shared::SharedTypesPlugin);
+        app.world_mut().insert_resource(SceneComposition::default());
+        let source = AudioSourceDesc {
+            clip: Some(
+                shared::EditorAssetRef::new("audio-id", shared::AUDIO_CLIP_SUB_ASSET_ID, "Impact")
+                    .with_source_path("assets/audio/impact.ogg"),
+            ),
+            ..Default::default()
+        };
+        let entity = app
+            .world_mut()
+            .spawn((
+                Name::new("Audio Source"),
+                Transform::IDENTITY,
+                LevelObject,
+                ActorId::new("audio-source"),
+                ActorKind::AudioSource,
+                source.clone(),
+            ))
+            .id();
+
+        let text = serialize_entities_inner(app.world_mut(), vec![entity]).unwrap();
+        let document = SceneDocument::from_ron_text(&text).unwrap();
+        let component = document.entities[0]
+            .components
+            .iter()
+            .find(|component| component.type_name == shared::COMPONENT_AUDIO_SOURCE_DESC)
+            .expect("audio source descriptor persisted");
+        let decoded: AudioSourceDesc = ron::from_str(&component.ron).unwrap();
+
+        assert_eq!(decoded, source);
+        assert!(!text.contains("bevy_audio::"));
+        assert!(!text.contains("AuthoredAudioVoice"));
+    }
+
+    #[test]
+    fn animation_controller_round_trip_excludes_runtime_animation_components() {
+        use bevy::animation::prelude::{
+            AnimationGraphHandle, AnimationPlayer, AnimationTransitions,
+        };
+        use shared::{
+            animation_clip_sub_asset_id, animation_skeleton_sub_asset_id, AnimationPlaybackRange,
+            AnimationStateDesc, EditorAssetRef,
+        };
+
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(shared::SharedTypesPlugin);
+        app.world_mut().insert_resource(SceneComposition::default());
+        let source_path = "assets/models/animated.glb";
+        let controller = AnimationControllerDesc {
+            skeleton: Some(
+                EditorAssetRef::new(
+                    "animated-model-id",
+                    animation_skeleton_sub_asset_id(0, "Rig"),
+                    "Rig",
+                )
+                .with_source_path(source_path),
+            ),
+            states: vec![AnimationStateDesc {
+                id: "locomotion.idle".into(),
+                label: "Idle".into(),
+                clip: EditorAssetRef::new(
+                    "animated-model-id",
+                    animation_clip_sub_asset_id(0, "Idle"),
+                    "Idle",
+                )
+                .with_source_path(source_path),
+                looping: true,
+                speed: 1.0,
+                range: AnimationPlaybackRange {
+                    start_seconds: 0.1,
+                    end_seconds: Some(1.25),
+                },
+            }],
+            default_state: "locomotion.idle".into(),
+            default_crossfade_seconds: 0.15,
+        };
+        let entity = app
+            .world_mut()
+            .spawn((
+                Name::new("Animated Model"),
+                Transform::IDENTITY,
+                LevelObject,
+                ActorId::new("animated-model"),
+                ActorKind::ImportedModel,
+                ModelRef::new(source_path),
+                controller.clone(),
+                AnimationPlayer::default(),
+                AnimationGraphHandle::default(),
+                AnimationTransitions::new(),
+            ))
+            .id();
+
+        let text = serialize_entities_inner(app.world_mut(), vec![entity]).unwrap();
+        let document = SceneDocument::from_ron_text(&text).unwrap();
+        let component = document.entities[0]
+            .components
+            .iter()
+            .find(|component| component.type_name == shared::COMPONENT_ANIMATION_CONTROLLER_DESC)
+            .expect("animation controller descriptor persisted");
+        let decoded: AnimationControllerDesc = ron::from_str(&component.ron).unwrap();
+
+        assert_eq!(decoded, controller);
+        assert!(!text.contains("AnimationPlayer"));
+        assert!(!text.contains("AnimationGraphHandle"));
+        assert!(!text.contains("AnimationTransitions"));
+    }
+
+    #[test]
+    fn linked_prefab_members_are_not_authored_scene_entities() {
+        let mut world = World::new();
+        let root = world.spawn((LevelObject, ActorKind::PrefabAnchor)).id();
+        let authored = world.spawn((LevelObject, ActorKind::Empty)).id();
+        let generated = world
+            .spawn((
+                LevelObject,
+                ActorKind::Empty,
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        let entities = authored_scene_entities(&mut world);
+
+        assert!(entities.contains(&root));
+        assert!(entities.contains(&authored));
+        assert!(!entities.contains(&generated));
+    }
+
+    #[test]
+    fn serializing_prefab_anchor_preserves_live_world_instance() {
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
+            .register_type::<Name>()
+            .register_type::<Transform>()
+            .register_type::<LevelObject>()
+            .register_type::<ActorId>()
+            .register_type::<ActorKind>()
+            .register_type::<PrefabInstance>();
+
+        let mut source = World::new();
+        source.spawn((LevelObject, ActorId::new("source-child")));
+        let dynamic_world = DynamicWorld::from_world_with(
+            &source,
+            &app.world().resource::<AppTypeRegistry>().read(),
+        );
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(dynamic_world);
+        let root = app
+            .world_mut()
+            .spawn((
+                Name::new("Linked Prefab"),
+                Transform::default(),
+                LevelObject,
+                ActorId::new("prefab-anchor"),
+                ActorKind::PrefabAnchor,
+                PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron"),
+                DynamicWorldRoot(handle),
+            ))
+            .id();
+
+        app.update();
+
+        let instance_id = **app
+            .world()
+            .get::<WorldInstance>(root)
+            .expect("prefab should be registered before save");
+        let spawned_before: Vec<_> = app
+            .world()
+            .resource::<WorldInstanceSpawner>()
+            .iter_instance_entities(instance_id)
+            .collect();
+        assert_eq!(spawned_before.len(), 1);
+
+        serialize_entities_inner_with_resources(app.world_mut(), vec![root], false).unwrap();
+
+        assert!(app.world().get::<DynamicWorldRoot>(root).is_some());
+        assert_eq!(
+            app.world().get::<WorldInstance>(root).map(|value| **value),
+            Some(instance_id)
+        );
+        let spawner = app.world().resource::<WorldInstanceSpawner>();
+        assert!(spawner.instance_is_ready(instance_id));
+        assert_eq!(
+            spawner
+                .iter_instance_entities(instance_id)
+                .collect::<Vec<_>>(),
+            spawned_before
+        );
+    }
+
+    #[test]
+    fn prefab_export_expands_local_children_and_nested_instances_only() {
+        let mut world = World::new();
+        let root = world.spawn((LevelObject, PrefabInstance::default())).id();
+        let local = world.spawn((LevelObject, ChildOf(root))).id();
+        let nested = world
+            .spawn((LevelObject, PrefabInstance::default(), ChildOf(local)))
+            .id();
+        let generated = world
+            .spawn((
+                LevelObject,
+                ChildOf(root),
+                HydratedPrefabMember {
+                    instance_root: root,
+                },
+            ))
+            .id();
+        let generated_descendant = world.spawn((LevelObject, ChildOf(generated))).id();
+
+        let expanded = expand_authored_selection(&world, &[root]);
+
+        assert!(expanded.contains(&root));
+        assert!(expanded.contains(&local));
+        assert!(expanded.contains(&nested));
+        assert!(!expanded.contains(&generated));
+        assert!(!expanded.contains(&generated_descendant));
+    }
+
+    #[test]
+    fn standalone_export_detaches_external_parent_and_restores_live_hierarchy() {
+        let mut app = App::new();
+        app.register_type::<Name>()
+            .register_type::<Transform>()
+            .register_type::<ChildOf>()
+            .register_type::<LevelObject>()
+            .register_type::<ActorId>()
+            .register_type::<ActorKind>();
+        let world = app.world_mut();
+        let parent = world
+            .spawn((
+                Name::new("Scene Parent"),
+                Transform::from_xyz(10.0, 0.0, 0.0),
+                LevelObject,
+                ActorId::new("parent"),
+                ActorKind::Empty,
+            ))
+            .id();
+        let child = world
+            .spawn((
+                Name::new("Exported Root"),
+                Transform::from_xyz(1.0, 2.0, 3.0),
+                LevelObject,
+                ActorId::new("child"),
+                ActorKind::Empty,
+                ChildOf(parent),
+            ))
+            .id();
+
+        let text = serialize_entities_inner_with_resources(world, vec![child], false).unwrap();
+
+        assert!(!text.contains("bevy_ecs::hierarchy::ChildOf"));
+        assert_eq!(world.get::<ChildOf>(child).unwrap().parent(), parent);
+        assert_eq!(
+            world.get::<Transform>(child).unwrap().translation,
+            Vec3::new(1.0, 2.0, 3.0),
+            "standalone export must restore the live local transform"
+        );
+        let document = SceneDocument::from_ron_text(&text).unwrap();
+        assert_eq!(document.entities.len(), 1);
+        assert_eq!(document.entities[0].actor_id.as_deref(), Some("child"));
+        let transform = document.entities[0]
+            .components
+            .iter()
+            .find(|component| component.type_name == scene::document::TRANSFORM_COMPONENT)
+            .and_then(|component| ron::from_str::<Transform>(&component.ron).ok())
+            .expect("standalone root should retain a serialized transform");
+        assert_eq!(transform.translation, Vec3::new(11.0, 2.0, 3.0));
+    }
+
+    #[test]
+    fn prefab_export_backfills_missing_and_duplicate_actor_ids() {
+        let mut world = World::new();
+        let existing = world.spawn((LevelObject, ActorId::new("occupied"))).id();
+        let duplicate = world.spawn((LevelObject, ActorId::new("occupied"))).id();
+        let missing = world.spawn(LevelObject).id();
+
+        assert_eq!(
+            ensure_unique_actor_ids(&mut world, &[duplicate, missing]),
+            2
+        );
+
+        let existing_id = world.get::<ActorId>(existing).unwrap().0.clone();
+        let duplicate_id = world.get::<ActorId>(duplicate).unwrap().0.clone();
+        let missing_id = world.get::<ActorId>(missing).unwrap().0.clone();
+        assert_eq!(existing_id, "occupied");
+        assert_ne!(duplicate_id, existing_id);
+        assert_ne!(missing_id, existing_id);
+        assert_ne!(missing_id, duplicate_id);
+    }
+
+    #[test]
+    fn scene_serialization_round_trip_preserves_parent_and_manual_sibling_order() {
+        let mut app = App::new();
+        app.register_type::<Name>()
+            .register_type::<Transform>()
+            .register_type::<ChildOf>()
+            .register_type::<LevelObject>()
+            .register_type::<ActorKind>()
+            .register_type::<HierarchySiblingIndex>();
+        let world = app.world_mut();
+        let parent = world
+            .spawn((
+                Name::new("Parent"),
+                Transform::default(),
+                LevelObject,
+                ActorKind::Empty,
+                HierarchySiblingIndex(0),
+            ))
+            .id();
+        let second = world
+            .spawn((
+                Name::new("Second"),
+                Transform::default(),
+                LevelObject,
+                ActorKind::Empty,
+                HierarchySiblingIndex(1),
+                ChildOf(parent),
+            ))
+            .id();
+        let first = world
+            .spawn((
+                Name::new("First"),
+                Transform::default(),
+                LevelObject,
+                ActorKind::Empty,
+                HierarchySiblingIndex(0),
+                ChildOf(parent),
+            ))
+            .id();
+
+        let text = serialize_entities_inner(world, vec![parent, second, first]).unwrap();
+        world.despawn(first);
+        world.despawn(second);
+        world.despawn(parent);
+
+        let bevy_ron = strip_schema_version(
+            SceneDocument::from_ron_text(&text)
+                .unwrap()
+                .normalized_ron(),
+        )
+        .unwrap();
+        let dynamic_world: DynamicWorld = {
+            let registry = world.resource::<AppTypeRegistry>().read();
+            let mut no_assets = NoAssetLoads;
+            let mut deserializer = ron::de::Deserializer::from_str(&bevy_ron).unwrap();
+            WorldDeserializer {
+                type_registry: &registry,
+                load_from_path: &mut no_assets,
+            }
+            .deserialize(&mut deserializer)
+            .unwrap()
+        };
+        dynamic_world
+            .write_to_world(world, &mut EntityHashMap::default())
+            .unwrap();
+
+        let mut query = world.query::<(Entity, &Name, &HierarchySiblingIndex, Option<&ChildOf>)>();
+        let rows: Vec<_> = query
+            .iter(world)
+            .map(|(entity, name, index, parent)| {
+                (
+                    entity,
+                    name.to_string(),
+                    index.0,
+                    parent.map(ChildOf::parent),
+                )
+            })
+            .collect();
+        let parent = rows
+            .iter()
+            .find(|(_, name, _, _)| name == "Parent")
+            .map(|(entity, _, _, _)| *entity)
+            .unwrap();
+        let first = rows.iter().find(|(_, name, _, _)| name == "First").unwrap();
+        let second = rows
+            .iter()
+            .find(|(_, name, _, _)| name == "Second")
+            .unwrap();
+
+        assert_eq!((first.2, first.3), (0, Some(parent)));
+        assert_eq!((second.2, second.3), (1, Some(parent)));
+    }
+
+    #[test]
+    fn composed_subscene_loads_with_stable_ownership_and_lock() {
+        let root =
+            std::env::temp_dir().join(format!("blacksite-composed-load-{}", uuid::Uuid::new_v4()));
+        let levels = root.join("assets/levels");
+        std::fs::create_dir_all(&levels).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let main_path = levels.join("main.scn.ron");
+        let child_path = levels.join("geometry.scn.ron");
+        std::fs::write(
+            &main_path,
+            r#"(schema_version: 2,
+  resources: {
+    "shared::components::SceneComposition": (
+      scene_id: "main-scene",
+      subscenes: [(
+        id: "geometry-ref",
+        path: "assets/levels/geometry.scn.ron",
+        visible: true,
+        locked: true,
+      )],
+    ),
+  },
+  entities: {},
+)"#,
+        )
+        .unwrap();
+        std::fs::write(
+            &child_path,
+            r#"(schema_version: 2,
+  resources: {
+    "shared::components::SceneComposition": (
+      scene_id: "geometry-scene",
+      subscenes: [],
+    ),
+  },
+  entities: {
+    1: (components: {
+      "bevy_ecs::name::Name": "Composed Geometry",
+      "bevy_transform::components::transform::Transform": (
+        translation: (0.0, 0.0, 0.0),
+        rotation: (0.0, 0.0, 0.0, 1.0),
+        scale: (1.0, 1.0, 1.0),
+      ),
+      "shared::components::LevelObject": (),
+      "shared::components::ActorKind": Empty,
+    }),
+  },
+)"#,
+        )
+        .unwrap();
+
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin::default())
+            .add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
+            .init_asset::<Mesh>()
+            .add_plugins(shared::SharedTypesPlugin);
+        app.world_mut()
+            .insert_resource(settings::ProjectSettings::default());
+        app.world_mut()
+            .insert_resource(crate::project_io::ProjectWorkspace {
+                root: root.display().to_string(),
+                ..Default::default()
+            });
+        app.world_mut()
+            .insert_resource(crate::ui::hierarchy_state::HierarchyPanelState::default());
+
+        load_level(app.world_mut(), &main_path).unwrap();
+
+        let world = app.world_mut();
+        assert_eq!(world.resource::<SceneComposition>().scene_id, "main-scene");
+        let mut query = world.query::<(Entity, &Name, &ComposedSceneMember)>();
+        let rows: Vec<_> = query
+            .iter(world)
+            .map(|(entity, name, member)| {
+                (
+                    entity,
+                    name.to_string(),
+                    member.reference_id.clone(),
+                    member.scene_id.clone(),
+                    member.source_path.clone(),
+                )
+            })
+            .collect();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].1, "Composed Geometry");
+        assert_eq!(rows[0].2, "geometry-ref");
+        assert_eq!(rows[0].3, "geometry-scene");
+        assert_eq!(rows[0].4, child_path.canonicalize().unwrap());
+        assert!(world
+            .resource::<crate::ui::hierarchy_state::HierarchyPanelState>()
+            .locked
+            .contains(&rows[0].0));
+
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn broken_prefab_source_loads_as_repairable_blocked_anchor() {
+        let root =
+            std::env::temp_dir().join(format!("blacksite-broken-prefab-{}", uuid::Uuid::new_v4()));
+        let levels = root.join("assets/levels");
+        std::fs::create_dir_all(&levels).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let level_path = levels.join("main.scn.ron");
+        std::fs::write(
+            &level_path,
+            r#"(schema_version: 2, resources: {}, entities: {
+  1: (components: {
+    "bevy_ecs::name::Name": "Broken Prefab",
+    "bevy_transform::components::transform::Transform": (
+      translation: (0.0, 0.0, 0.0),
+      rotation: (0.0, 0.0, 0.0, 1.0),
+      scale: (1.0, 1.0, 1.0),
+    ),
+    "shared::components::LevelObject": (),
+    "shared::components::ActorId": ("broken-anchor"),
+    "shared::components::ActorKind": PrefabAnchor,
+    "shared::components::PrefabRef": (path: "assets/prefabs/missing.scn.ron"),
+    "shared::components::PrefabInstance": (
+      asset_id: "missing-asset",
+      source_path: "assets/prefabs/missing.scn.ron",
+      overrides_ron: None,
+    ),
+  }),
+  2: (components: {
+    "bevy_ecs::name::Name": "Broken Legacy Prefab",
+    "bevy_transform::components::transform::Transform": (
+      translation: (0.0, 0.0, 0.0),
+      rotation: (0.0, 0.0, 0.0, 1.0),
+      scale: (1.0, 1.0, 1.0),
+    ),
+    "shared::components::LevelObject": (),
+    "shared::components::ActorId": ("broken-legacy-anchor"),
+    "shared::components::ActorKind": PrefabAnchor,
+    "shared::components::PrefabRef": (path: "assets/prefabs/legacy-missing.scn.ron"),
+  }),
+})"#,
+        )
+        .unwrap();
+
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin::default())
+            .add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
+            .init_asset::<Mesh>()
+            .add_plugins(shared::SharedTypesPlugin);
+        app.world_mut()
+            .insert_resource(settings::ProjectSettings::default());
+        app.world_mut()
+            .insert_resource(crate::project_io::ProjectWorkspace {
+                root: root.display().to_string(),
+                ..Default::default()
+            });
+        app.world_mut()
+            .insert_resource(crate::ui::hierarchy_state::HierarchyPanelState::default());
+
+        load_level(app.world_mut(), &level_path).unwrap();
+
+        let world = app.world_mut();
+        let blocked: Vec<_> = world
+            .query::<(Entity, &PrefabHydrationBlocked)>()
+            .iter(world)
+            .map(|(entity, blocked)| (entity, blocked.reason.clone()))
+            .collect();
+        assert_eq!(blocked.len(), 2);
+        for (entity, reason) in blocked {
+            assert!(reason.contains("missing prefab source"));
+            assert!(world.get::<PrefabInstance>(entity).is_some());
+            assert!(world.get::<DynamicWorldRoot>(entity).is_none());
+            assert!(world.get::<HydratedPrefabReady>(entity).is_none());
+        }
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn saving_open_legacy_prefab_repairs_actor_ids() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-legacy-prefab-save-{}",
+            uuid::Uuid::new_v4()
+        ));
+        let prefabs = root.join("assets/prefabs");
+        std::fs::create_dir_all(&prefabs).unwrap();
+        std::fs::write(root.join("assets/project.ron"), "()").unwrap();
+        let prefab_path = prefabs.join("legacy.scn.ron");
+        std::fs::write(
+            &prefab_path,
+            r#"(schema_version: 2, resources: {}, entities: {
+  1: (components: {
+    "bevy_ecs::name::Name": "Missing ID",
+    "bevy_transform::components::transform::Transform": (
+      translation: (0.0, 0.0, 0.0),
+      rotation: (0.0, 0.0, 0.0, 1.0),
+      scale: (1.0, 1.0, 1.0),
+    ),
+    "shared::components::LevelObject": (),
+    "shared::components::ActorKind": Empty,
+  }),
+  2: (components: {
+    "bevy_ecs::name::Name": "Duplicate A",
+    "bevy_transform::components::transform::Transform": (
+      translation: (1.0, 0.0, 0.0),
+      rotation: (0.0, 0.0, 0.0, 1.0),
+      scale: (1.0, 1.0, 1.0),
+    ),
+    "shared::components::LevelObject": (),
+    "shared::components::ActorId": ("duplicate"),
+    "shared::components::ActorKind": Empty,
+  }),
+  3: (components: {
+    "bevy_ecs::name::Name": "Duplicate B",
+    "bevy_transform::components::transform::Transform": (
+      translation: (2.0, 0.0, 0.0),
+      rotation: (0.0, 0.0, 0.0, 1.0),
+      scale: (1.0, 1.0, 1.0),
+    ),
+    "shared::components::LevelObject": (),
+    "shared::components::ActorId": ("duplicate"),
+    "shared::components::ActorKind": Empty,
+  }),
+})"#,
+        )
+        .unwrap();
+
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin::default())
+            .add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
+            .init_asset::<Mesh>()
+            .add_plugins(shared::SharedTypesPlugin);
+        app.world_mut()
+            .insert_resource(settings::ProjectSettings::default());
+        app.world_mut()
+            .insert_resource(crate::project_io::ProjectWorkspace {
+                root: root.display().to_string(),
+                ..Default::default()
+            });
+        app.world_mut()
+            .insert_resource(crate::ui::hierarchy_state::HierarchyPanelState::default());
+        app.world_mut().init_resource::<SceneIo>();
+
+        load_level(app.world_mut(), &prefab_path).unwrap();
+        save_level(app.world_mut(), &prefab_path).unwrap();
+
+        scene::validate_prefab_graph(&prefab_path, &root).unwrap();
+        let document =
+            SceneDocument::from_ron_text(&std::fs::read_to_string(&prefab_path).unwrap()).unwrap();
+        let ids: HashSet<_> = document
+            .entities
+            .iter()
+            .map(|entity| entity.actor_id.clone().expect("ActorId must be repaired"))
+            .collect();
+        assert_eq!(ids.len(), 3);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn scene_io_event_log_is_bounded_and_classifies_failures() {
+        let mut io = SceneIo::default();
+        for index in 0..(MAX_SCENE_IO_EVENTS + 3) {
+            io.set_status(format!("Saved scene {index}"));
+        }
+        io.set_status("Recovery snapshot failed: disk full");
+
+        assert_eq!(io.events.len(), MAX_SCENE_IO_EVENTS);
+        assert_eq!(
+            io.events.back().map(|event| event.severity),
+            Some(SceneIoEventSeverity::Error)
+        );
+        assert_eq!(
+            io.events.front().map(|event| event.id),
+            Some(5),
+            "oldest entries should be evicted first"
+        );
+    }
+
+    #[test]
+    fn recovery_copy_preserves_snapshot_bytes_without_retiring_source() {
+        let root =
+            std::env::temp_dir().join(format!("blacksite-recovery-copy-{}", uuid::Uuid::new_v4()));
+        let snapshot = root.join("recovery.scn.ron");
+        let destination = root.join("kept.scn.ron");
+        std::fs::create_dir_all(&root).unwrap();
+        std::fs::write(&snapshot, b"recovered scene bytes").unwrap();
+
+        write_recovery_copy(&snapshot, &destination).unwrap();
+
+        assert_eq!(
+            std::fs::read(&destination).unwrap(),
+            b"recovered scene bytes"
+        );
+        assert!(snapshot.exists());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/crates/editor/src/ui/actor_inspector/mod.rs b/crates/editor/src/ui/actor_inspector/mod.rs
index ffca47f..a1cd786 100644
--- a/crates/editor/src/ui/actor_inspector/mod.rs
+++ b/crates/editor/src/ui/actor_inspector/mod.rs
@@ -5,11 +5,12 @@ mod transform;
 use bevy::prelude::*;
 use bevy_egui::egui;
 use egui_phosphor_icons::icons;
-use shared::{ActorId, ActorKind, ActorName, LevelObject};
+use shared::{ActorId, ActorKind, ActorName, HydratedPrefabMember, LevelObject};
 
 use crate::ext::extensibility::ActorInspectorSectionRegistry;
 use crate::ui::inspector;
-use crate::ui::theme::{panel_heading, BORDER, TEXT_DIM, WIDGET_BG};
+use crate::ui::selection_ops::is_linked_read_only;
+use crate::ui::theme::{panel_heading, BORDER, SELECTION, TEXT, TEXT_DIM, WIDGET_BG};
 use crate::ui::widgets::phosphor_icon;
 
 use transform::transform_inspector_ui;
@@ -17,6 +18,8 @@ use transform::transform_inspector_ui;
 const COMPACT_ACTOR_HEADER_WIDTH: f32 = 360.0;
 
 pub fn draw_actor_inspector(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
+    let linked_read_only = is_linked_read_only(world, entity);
+    let prefab_member = world.get::<HydratedPrefabMember>(entity).is_some();
     let Some(entity_ref) = world.get_entity(entity).ok() else {
         ui.label("Entity no longer exists.");
         return;
@@ -79,34 +82,59 @@ pub fn draw_actor_inspector(world: &mut World, ui: &mut egui::Ui, entity: Entity
         });
     ui.add_space(6.0);
 
-    egui::ScrollArea::vertical()
-        .auto_shrink([false, false])
-        .show(ui, |ui| {
-            transform_inspector_ui(world, ui, entity);
+    if linked_read_only {
+        ui.small(
+            egui::RichText::new(if prefab_member {
+                "Linked prefab member"
+            } else {
+                "Linked scene member"
+            })
+            .color(TEXT_DIM),
+        );
+        ui.add_space(4.0);
+    }
 
-            match kind {
-                ActorKind::StaticMesh
-                | ActorKind::Brush
-                | ActorKind::ImportedModel
-                | ActorKind::Light
-                | ActorKind::Empty
-                | ActorKind::PrefabAnchor
-                | ActorKind::PlayerSpawn
-                | ActorKind::WeaponSpawn
-                | ActorKind::TriggerVolume
-                | ActorKind::PostProcessVolume
-                | ActorKind::TeamSpawn
-                | ActorKind::Objective => {
-                    inspector::authoring_inspector_ui(world, ui, entity);
-                }
-            }
-
-            world.resource_scope(|world, registry: Mut<ActorInspectorSectionRegistry>| {
-                registry.draw_sections(world, ui, entity);
+    if prefab_member {
+        egui::ScrollArea::vertical()
+            .auto_shrink([false, false])
+            .show(ui, |ui| {
+                crate::assets::prefab_overrides::prefab_member_inspector_ui(world, ui, entity);
             });
+        return;
+    }
 
-            inspector::add_component_footer(world, ui, entity);
-        });
+    ui.add_enabled_ui(!linked_read_only, |ui| {
+        egui::ScrollArea::vertical()
+            .auto_shrink([false, false])
+            .show(ui, |ui| {
+                transform_inspector_ui(world, ui, entity);
+
+                match kind {
+                    ActorKind::StaticMesh
+                    | ActorKind::Brush
+                    | ActorKind::ImportedModel
+                    | ActorKind::Light
+                    | ActorKind::Empty
+                    | ActorKind::PrefabAnchor
+                    | ActorKind::PlayerSpawn
+                    | ActorKind::WeaponSpawn
+                    | ActorKind::TriggerVolume
+                    | ActorKind::PostProcessVolume
+                    | ActorKind::TeamSpawn
+                    | ActorKind::Objective
+                    | ActorKind::AudioSource
+                    | ActorKind::AudioListener => {
+                        inspector::authoring_inspector_ui(world, ui, entity);
+                    }
+                }
+
+                world.resource_scope(|world, registry: Mut<ActorInspectorSectionRegistry>| {
+                    registry.draw_sections(world, ui, entity);
+                });
+
+                inspector::add_component_footer(world, ui, entity);
+            });
+    });
 }
 
 fn actor_icon(kind: ActorKind) -> egui_phosphor_icons::Icon {
@@ -119,14 +147,52 @@ fn actor_icon(kind: ActorKind) -> egui_phosphor_icons::Icon {
         ActorKind::TriggerVolume => icons::SELECTION,
         ActorKind::PostProcessVolume => icons::APERTURE,
         ActorKind::TeamSpawn | ActorKind::Objective => icons::FLAG,
+        ActorKind::AudioSource => icons::SPEAKER_HIGH,
+        ActorKind::AudioListener => icons::HEADPHONES,
         ActorKind::Empty => icons::CIRCLE,
     }
 }
 
 pub fn draw_multi_actor_inspector(world: &mut World, ui: &mut egui::Ui, entities: &[Entity]) {
-    ui.heading(format!("{} objects selected", entities.len()));
-    ui.label("Multi-edit: use the viewport gizmo for shared transform.");
+    if entities.is_empty() {
+        egui::Frame::new()
+            .fill(WIDGET_BG)
+            .stroke(egui::Stroke::new(1.0, BORDER))
+            .corner_radius(egui::CornerRadius::same(4))
+            .inner_margin(egui::Margin::symmetric(10, 10))
+            .show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label(phosphor_icon(icons::SELECTION, 24.0).color(TEXT_DIM));
+                    ui.label(egui::RichText::new("No selection").color(TEXT_DIM).strong());
+                });
+            });
+        return;
+    }
     if entities.len() == 1 {
         draw_actor_inspector(world, ui, entities[0]);
+        return;
     }
+
+    egui::Frame::new()
+        .fill(WIDGET_BG)
+        .stroke(egui::Stroke::new(1.0, BORDER))
+        .corner_radius(egui::CornerRadius::same(4))
+        .inner_margin(egui::Margin::symmetric(10, 10))
+        .show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.label(phosphor_icon(icons::SELECTION_ALL, 26.0).color(SELECTION));
+                ui.vertical(|ui| {
+                    ui.label(
+                        egui::RichText::new(format!("{} objects selected", entities.len()))
+                            .color(TEXT)
+                            .strong(),
+                    );
+                    ui.label(
+                        egui::RichText::new("Shared transform gizmo")
+                            .color(TEXT_DIM)
+                            .small(),
+                    );
+                });
+            });
+        });
 }
diff --git a/crates/editor/src/ui/animation_inspector.rs b/crates/editor/src/ui/animation_inspector.rs
new file mode 100644
index 0000000..bbe7bf9
--- /dev/null
+++ b/crates/editor/src/ui/animation_inspector.rs
@@ -0,0 +1,1023 @@
+//! Animation controller authoring and transient viewport preview controls.
+
+use std::collections::HashMap;
+
+use bevy::prelude::*;
+use bevy_egui::egui;
+use egui_phosphor_icons::icons;
+use shared::{
+    AnimationClipRecord, AnimationControllerDesc, AnimationManifest, AnimationSkeletonRecord,
+    AnimationStateDesc, EditorAssetRef, ModelRef, COMPONENT_ANIMATION_CONTROLLER_DESC,
+};
+
+use crate::assets::animation::load_animation_manifest;
+use crate::assets::asset_db::{find_asset_by_id, find_asset_by_path, AssetRegistry};
+use crate::history::set_animation_controller_with_history;
+use crate::ui::inspector::{
+    apply_component_card_response, component_card, component_card_context, property_row,
+    text_field_width, ComponentCardOptions,
+};
+use crate::ui::theme::{ERROR, SUCCESS, TEXT_DIM, TEXT_MUTED, WARNING};
+use crate::ui::widgets::icon_button_small;
+
+#[derive(Resource, Default)]
+pub(crate) struct AnimationInspectorState {
+    selected_state: HashMap<Entity, String>,
+    scrub_seconds: HashMap<Entity, f32>,
+}
+
+#[derive(Debug, Clone)]
+enum PreviewAction {
+    Set(game::animation::AnimationPreviewRequest),
+    Stop,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ClipCompatibility {
+    Compatible,
+    Unknown,
+    Mismatch,
+}
+
+impl ClipCompatibility {
+    fn label(self) -> &'static str {
+        match self {
+            Self::Compatible => "Compatible",
+            Self::Unknown => "Compatibility unknown",
+            Self::Mismatch => "Skeleton mismatch",
+        }
+    }
+
+    fn color(self) -> egui::Color32 {
+        match self {
+            Self::Compatible => SUCCESS,
+            Self::Unknown => WARNING,
+            Self::Mismatch => ERROR,
+        }
+    }
+}
+
+pub(crate) fn default_controller_for_actor(
+    world: &World,
+    entity: Entity,
+) -> AnimationControllerDesc {
+    manifest_for_actor(world, entity)
+        .map(|manifest| controller_from_manifest(&manifest))
+        .unwrap_or_default()
+}
+
+pub(crate) fn stop_preview_if_actor(world: &mut World, entity: Entity) {
+    let previewing_actor = world
+        .get_resource::<game::animation::AnimationPreviewRuntime>()
+        .and_then(|runtime| runtime.request.as_ref())
+        .is_some_and(|request| request.actor == entity);
+    if previewing_actor {
+        game::animation::stop_animation_preview(world);
+    }
+    if let Some(mut state) = world.get_resource_mut::<AnimationInspectorState>() {
+        state.selected_state.remove(&entity);
+        state.scrub_seconds.remove(&entity);
+    }
+}
+
+pub(crate) fn animation_controller_inspector_ui(
+    world: &mut World,
+    ui: &mut egui::Ui,
+    entity: Entity,
+) {
+    let Some(mut controller) = world.get::<AnimationControllerDesc>(entity).cloned() else {
+        return;
+    };
+    let original = controller.clone();
+    let manifest_result = manifest_for_actor(world, entity);
+    let manifest = manifest_result.as_ref().ok();
+    let referenced_clip_manifests = referenced_clip_manifests(world, &controller, manifest);
+    let active_preview = world
+        .get_resource::<game::animation::AnimationPreviewRuntime>()
+        .and_then(|runtime| runtime.request.clone());
+    let stored_selection = world
+        .get_resource::<AnimationInspectorState>()
+        .and_then(|state| state.selected_state.get(&entity).cloned());
+    let stored_scrub = world
+        .get_resource::<AnimationInspectorState>()
+        .and_then(|state| state.scrub_seconds.get(&entity).copied());
+    let mut selected_state = active_preview
+        .as_ref()
+        .filter(|request| request.actor == entity)
+        .map(|request| request.state_id.clone())
+        .or(stored_selection)
+        .filter(|id| controller.state(id).is_some())
+        .or_else(|| {
+            controller
+                .state(&controller.default_state)
+                .map(|state| state.id.clone())
+        })
+        .or_else(|| controller.states.first().map(|state| state.id.clone()))
+        .unwrap_or_default();
+    let mut scrub_seconds = active_preview
+        .as_ref()
+        .filter(|request| request.actor == entity)
+        .and_then(|request| request.seek_seconds)
+        .or(stored_scrub)
+        .unwrap_or_else(|| {
+            controller
+                .state(&selected_state)
+                .map(|state| state.range.start_seconds)
+                .unwrap_or(0.0)
+        });
+    let mut preview_action = None;
+
+    let card = component_card_context(
+        world,
+        entity,
+        ComponentCardOptions::removable(
+            COMPONENT_ANIMATION_CONTROLLER_DESC,
+            "Animation Controller",
+            icons::FILM_SLATE,
+        ),
+    );
+    let card_response = component_card(ui, &card, |ui| {
+        manifest_summary(ui, &manifest_result);
+
+        property_row(ui, "Skeleton", |ui| {
+            if let Some(manifest) = manifest {
+                let selected = controller
+                    .skeleton
+                    .as_ref()
+                    .map(|skeleton| skeleton.label.as_str())
+                    .filter(|label| !label.trim().is_empty())
+                    .unwrap_or("None");
+                egui::ComboBox::from_id_salt(("animation_skeleton", entity))
+                    .selected_text(selected)
+                    .width(text_field_width(ui))
+                    .show_ui(ui, |ui| {
+                        ui.selectable_value(&mut controller.skeleton, None, "None");
+                        for skeleton in &manifest.skeletons {
+                            let reference = skeleton_ref(manifest, skeleton);
+                            ui.selectable_value(
+                                &mut controller.skeleton,
+                                Some(reference),
+                                &skeleton.label,
+                            );
+                        }
+                    });
+            } else {
+                ui.add_enabled(false, egui::Label::new("Manifest unavailable"));
+            }
+        });
+
+        property_row(ui, "Crossfade", |ui| {
+            ui.add(
+                egui::DragValue::new(&mut controller.default_crossfade_seconds)
+                    .range(0.0..=5.0)
+                    .speed(0.01)
+                    .suffix(" s"),
+            );
+        });
+
+        ui.add_space(4.0);
+        ui.horizontal(|ui| {
+            ui.strong("States");
+            ui.label(
+                egui::RichText::new(controller.states.len().to_string())
+                    .small()
+                    .color(TEXT_MUTED),
+            );
+        });
+        ui.separator();
+
+        let selected_skeleton = controller.skeleton.clone();
+        let mut state_id_counts = HashMap::new();
+        for state in &controller.states {
+            *state_id_counts.entry(state.id.clone()).or_insert(0_usize) += 1;
+        }
+        let mut default_state = controller.default_state.clone();
+        let mut remove_state = None;
+        for (index, state) in controller.states.iter_mut().enumerate() {
+            ui.push_id(("animation_state", entity, index), |ui| {
+                let heading = if state.label.trim().is_empty() {
+                    if state.id.trim().is_empty() {
+                        "Untitled State"
+                    } else {
+                        state.id.as_str()
+                    }
+                } else {
+                    state.label.as_str()
+                };
+                ui.horizontal(|ui| {
+                    ui.label(egui::RichText::new(heading).strong());
+                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                        if icon_button_small(ui, icons::TRASH, "Remove state").clicked() {
+                            remove_state = Some(index);
+                        }
+                        if default_state == state.id && !state.id.trim().is_empty() {
+                            ui.label(egui::RichText::new("DEFAULT").small().color(SUCCESS));
+                        }
+                    });
+                });
+
+                property_row(ui, "Name", |ui| {
+                    ui.add_sized(
+                        [text_field_width(ui), 20.0],
+                        egui::TextEdit::singleline(&mut state.label),
+                    );
+                });
+                let previous_id = state.id.clone();
+                property_row(ui, "State ID", |ui| {
+                    ui.add_sized(
+                        [text_field_width(ui), 20.0],
+                        egui::TextEdit::singleline(&mut state.id),
+                    );
+                });
+                if default_state == previous_id && state.id != previous_id {
+                    default_state.clone_from(&state.id);
+                }
+                if state.id.trim().is_empty() {
+                    ui.label(
+                        egui::RichText::new("State ID is required")
+                            .small()
+                            .color(ERROR),
+                    );
+                } else if state_id_counts.get(&previous_id).copied().unwrap_or(0) > 1 {
+                    ui.label(
+                        egui::RichText::new("State ID must be unique")
+                            .small()
+                            .color(ERROR),
+                    );
+                }
+
+                property_row(ui, "Clip", |ui| {
+                    if let Some(manifest) = manifest {
+                        let selected = if state.clip.label.trim().is_empty() {
+                            "None"
+                        } else {
+                            state.clip.label.as_str()
+                        };
+                        egui::ComboBox::from_id_salt("clip")
+                            .selected_text(selected)
+                            .width(text_field_width(ui))
+                            .show_ui(ui, |ui| {
+                                for clip in &manifest.clips {
+                                    let reference = clip_ref(manifest, clip);
+                                    let suffix = format!("{:.2} s", clip.duration_seconds);
+                                    ui.selectable_value(
+                                        &mut state.clip,
+                                        reference,
+                                        format!("{}  {}", clip.label, suffix),
+                                    );
+                                }
+                            });
+                    } else {
+                        ui.add_enabled(false, egui::Label::new(&state.clip.label));
+                    }
+                });
+
+                if let Some((primary, clip)) = manifest.and_then(|primary| {
+                    resolved_clip_for_ref(primary, &referenced_clip_manifests, &state.clip)
+                        .map(|clip| (primary, clip))
+                }) {
+                    let compatibility =
+                        clip_compatibility(primary, selected_skeleton.as_ref(), clip);
+                    ui.label(
+                        egui::RichText::new(compatibility.label())
+                            .small()
+                            .color(compatibility.color()),
+                    );
+                }
+
+                property_row(ui, "Playback", |ui| {
+                    ui.horizontal_wrapped(|ui| {
+                        ui.checkbox(&mut state.looping, "Loop");
+                        ui.label(egui::RichText::new("Speed").small().color(TEXT_DIM));
+                        ui.add(
+                            egui::DragValue::new(&mut state.speed)
+                                .range(0.01..=8.0)
+                                .speed(0.01)
+                                .suffix("x"),
+                        );
+                    });
+                });
+
+                let clip_duration = manifest
+                    .and_then(|manifest| {
+                        resolved_clip_for_ref(manifest, &referenced_clip_manifests, &state.clip)
+                    })
+                    .map(|clip| clip.duration_seconds.max(0.0));
+                property_row(ui, "Start", |ui| {
+                    let max = clip_duration.unwrap_or(86_400.0).max(0.01);
+                    ui.add(
+                        egui::DragValue::new(&mut state.range.start_seconds)
+                            .range(0.0..=max)
+                            .speed(0.01)
+                            .suffix(" s"),
+                    );
+                });
+                property_row(ui, "End", |ui| {
+                    ui.horizontal_wrapped(|ui| {
+                        let mut limited = state.range.end_seconds.is_some();
+                        if ui.checkbox(&mut limited, "Custom").changed() {
+                            state.range.end_seconds = limited.then(|| {
+                                clip_duration
+                                    .unwrap_or(state.range.start_seconds + 1.0)
+                                    .max(state.range.start_seconds + 0.01)
+                            });
+                        }
+                        if let Some(end) = state.range.end_seconds.as_mut() {
+                            let max = clip_duration
+                                .unwrap_or(86_400.0)
+                                .max(state.range.start_seconds + 0.01);
+                            ui.add(
+                                egui::DragValue::new(end)
+                                    .range((state.range.start_seconds + 0.01)..=max)
+                                    .speed(0.01)
+                                    .suffix(" s"),
+                            );
+                        } else if let Some(duration) = clip_duration {
+                            ui.label(
+                                egui::RichText::new(format!("Clip end ({duration:.2} s)"))
+                                    .small()
+                                    .color(TEXT_DIM),
+                            );
+                        }
+                    });
+                });
+                ui.add_space(4.0);
+                ui.separator();
+            });
+        }
+        controller.default_state = default_state;
+
+        if let Some(index) = remove_state {
+            let removed = controller.states.remove(index);
+            if controller.default_state == removed.id {
+                controller.default_state = controller
+                    .states
+                    .first()
+                    .map(|state| state.id.clone())
+                    .unwrap_or_default();
+            }
+            if selected_state == removed.id {
+                selected_state = controller
+                    .states
+                    .first()
+                    .map(|state| state.id.clone())
+                    .unwrap_or_default();
+                preview_action = Some(PreviewAction::Stop);
+            }
+        }
+
+        if ui
+            .add_enabled(
+                manifest.is_some_and(|manifest| !manifest.clips.is_empty()),
+                egui::Button::new(format!("{} Add State", icons::PLUS.as_str())),
+            )
+            .on_hover_text("Add an animation state")
+            .clicked()
+        {
+            if let Some(manifest) = manifest {
+                if let Some(clip) = preferred_clip(manifest, controller.skeleton.as_ref()) {
+                    let id = unique_state_id(
+                        &clip.label,
+                        controller.states.iter().map(|state| state.id.as_str()),
+                    );
+                    controller.states.push(AnimationStateDesc {
+                        id: id.clone(),
+                        label: clip.label.clone(),
+                        clip: clip_ref(manifest, clip),
+                        ..Default::default()
+                    });
+                    if controller.default_state.trim().is_empty() {
+                        controller.default_state.clone_from(&id);
+                    }
+                    selected_state = id;
+                    scrub_seconds = 0.0;
+                }
+            }
+        }
+
+        let default_choices = controller
+            .states
+            .iter()
+            .map(|state| (state.id.clone(), state_display_name(state).to_string()))
+            .collect::<Vec<_>>();
+        property_row(ui, "Default state", |ui| {
+            let selected = controller
+                .state(&controller.default_state)
+                .map(state_display_name)
+                .unwrap_or("None");
+            egui::ComboBox::from_id_salt(("animation_default", entity))
+                .selected_text(selected)
+                .width(text_field_width(ui))
+                .show_ui(ui, |ui| {
+                    for (id, label) in &default_choices {
+                        ui.selectable_value(&mut controller.default_state, id.clone(), label);
+                    }
+                });
+        });
+
+        ui.add_space(8.0);
+        ui.strong("Preview");
+        ui.separator();
+        if controller.state(&selected_state).is_none() {
+            selected_state = controller
+                .state(&controller.default_state)
+                .map(|state| state.id.clone())
+                .or_else(|| controller.states.first().map(|state| state.id.clone()))
+                .unwrap_or_default();
+        }
+        let preview_choices = controller
+            .states
+            .iter()
+            .map(|state| (state.id.clone(), state_display_name(state).to_string()))
+            .collect::<Vec<_>>();
+        let runtime_supported = manifest.is_some_and(|manifest| manifest.runtime_supported);
+        let preview_valid = controller.state(&selected_state).is_some_and(|state| {
+            state.clip.is_resolved()
+                && manifest.is_some_and(|manifest| {
+                    resolved_clip_for_ref(manifest, &referenced_clip_manifests, &state.clip)
+                        .is_some_and(|clip| {
+                            clip_compatibility(manifest, controller.skeleton.as_ref(), clip)
+                                != ClipCompatibility::Mismatch
+                        })
+                })
+        });
+        property_row(ui, "State", |ui| {
+            let selected = controller
+                .state(&selected_state)
+                .map(state_display_name)
+                .unwrap_or("None");
+            egui::ComboBox::from_id_salt(("animation_preview_state", entity))
+                .selected_text(selected)
+                .width(text_field_width(ui))
+                .show_ui(ui, |ui| {
+                    for (id, label) in &preview_choices {
+                        if ui
+                            .selectable_value(&mut selected_state, id.clone(), label)
+                            .clicked()
+                        {
+                            scrub_seconds = controller
+                                .state(id)
+                                .map(|state| state.range.start_seconds)
+                                .unwrap_or(0.0);
+                            preview_action = Some(PreviewAction::Set(
+                                game::animation::AnimationPreviewRequest {
+                                    actor: entity,
+                                    state_id: id.clone(),
+                                    seek_seconds: Some(scrub_seconds),
+                                    playing: false,
+                                },
+                            ));
+                        }
+                    }
+                });
+        });
+
+        let active_for_actor = active_preview
+            .as_ref()
+            .is_some_and(|request| request.actor == entity);
+        let active_playing = active_preview.as_ref().is_some_and(|request| {
+            request.actor == entity && request.state_id == selected_state && request.playing
+        });
+        property_row(ui, "Transport", |ui| {
+            ui.horizontal_wrapped(|ui| {
+                let icon = if active_playing {
+                    icons::PAUSE
+                } else {
+                    icons::PLAY
+                };
+                let label = if active_playing { "Pause" } else { "Play" };
+                if ui
+                    .add_enabled(
+                        runtime_supported && preview_valid,
+                        egui::Button::new(format!("{} {label}", icon.as_str())),
+                    )
+                    .clicked()
+                {
+                    preview_action = Some(PreviewAction::Set(
+                        game::animation::AnimationPreviewRequest {
+                            actor: entity,
+                            state_id: selected_state.clone(),
+                            seek_seconds: Some(scrub_seconds),
+                            playing: !active_playing,
+                        },
+                    ));
+                }
+                if ui
+                    .add_enabled(
+                        active_for_actor,
+                        egui::Button::new(format!("{} Stop", icons::STOP.as_str())),
+                    )
+                    .clicked()
+                {
+                    preview_action = Some(PreviewAction::Stop);
+                }
+            });
+        });
+
+        if let Some(state) = controller.state(&selected_state) {
+            let clip_end = manifest
+                .and_then(|manifest| {
+                    resolved_clip_for_ref(manifest, &referenced_clip_manifests, &state.clip)
+                })
+                .map(|clip| clip.duration_seconds)
+                .unwrap_or(state.range.start_seconds + 1.0);
+            let end = state
+                .range
+                .end_seconds
+                .unwrap_or(clip_end)
+                .max(state.range.start_seconds + 0.01);
+            scrub_seconds = scrub_seconds.clamp(state.range.start_seconds, end);
+            property_row(ui, "Time", |ui| {
+                ui.horizontal(|ui| {
+                    let response = ui.add_enabled(
+                        runtime_supported && preview_valid,
+                        egui::Slider::new(&mut scrub_seconds, state.range.start_seconds..=end)
+                            .show_value(false),
+                    );
+                    ui.label(
+                        egui::RichText::new(format!("{scrub_seconds:.2} / {end:.2} s"))
+                            .small()
+                            .color(TEXT_DIM),
+                    );
+                    if response.changed() {
+                        preview_action = Some(PreviewAction::Set(
+                            game::animation::AnimationPreviewRequest {
+                                actor: entity,
+                                state_id: selected_state.clone(),
+                                seek_seconds: Some(scrub_seconds),
+                                playing: false,
+                            },
+                        ));
+                    }
+                });
+            });
+        }
+        if manifest.is_some_and(|manifest| !manifest.runtime_supported) {
+            ui.label(
+                egui::RichText::new("Preview unavailable for this source format")
+                    .small()
+                    .color(WARNING),
+            );
+        }
+    });
+
+    controller.default_crossfade_seconds = controller.default_crossfade_seconds.max(0.0);
+    for state in &mut controller.states {
+        state.speed = state.speed.max(0.01);
+        state.range.start_seconds = state.range.start_seconds.max(0.0);
+        if let Some(end) = state.range.end_seconds.as_mut() {
+            *end = end.max(state.range.start_seconds + 0.01);
+        }
+    }
+
+    let changed = controller != original;
+    if changed {
+        set_animation_controller_with_history(world, entity, controller.clone());
+    }
+    let active_state_still_exists = active_preview
+        .as_ref()
+        .filter(|request| request.actor == entity)
+        .is_none_or(|request| controller.state(&request.state_id).is_some());
+    if !active_state_still_exists {
+        game::animation::stop_animation_preview(world);
+    }
+    match preview_action {
+        Some(PreviewAction::Set(request)) if controller.state(&request.state_id).is_some() => {
+            if world
+                .get_resource::<game::animation::AnimationPreviewRuntime>()
+                .is_none()
+            {
+                set_status(world, "Animation preview failed: runtime is unavailable");
+            } else if let Err(error) = game::animation::set_animation_preview(world, request) {
+                set_status(world, format!("Animation preview failed: {error}"));
+            }
+        }
+        Some(PreviewAction::Set(_)) | Some(PreviewAction::Stop) => {
+            stop_preview_if_actor(world, entity);
+        }
+        None => {}
+    }
+    if let Some(mut state) = world.get_resource_mut::<AnimationInspectorState>() {
+        if selected_state.is_empty() {
+            state.selected_state.remove(&entity);
+        } else {
+            state.selected_state.insert(entity, selected_state);
+        }
+        state.scrub_seconds.insert(entity, scrub_seconds);
+    }
+    apply_component_card_response(world, entity, card_response);
+}
+
+fn manifest_summary(ui: &mut egui::Ui, manifest: &Result<AnimationManifest, String>) {
+    match manifest {
+        Ok(manifest) => {
+            let color = if manifest.runtime_supported {
+                SUCCESS
+            } else {
+                WARNING
+            };
+            ui.horizontal_wrapped(|ui| {
+                ui.label(
+                    egui::RichText::new(format!(
+                        "{} | {} rig{} | {} clip{}",
+                        manifest.source.format.to_ascii_uppercase(),
+                        manifest.skeletons.len(),
+                        if manifest.skeletons.len() == 1 {
+                            ""
+                        } else {
+                            "s"
+                        },
+                        manifest.clips.len(),
+                        if manifest.clips.len() == 1 { "" } else { "s" },
+                    ))
+                    .small()
+                    .color(color),
+                );
+            });
+            if let Some(diagnostic) = manifest.diagnostics.first() {
+                ui.label(
+                    egui::RichText::new(&diagnostic.message)
+                        .small()
+                        .color(WARNING),
+                )
+                .on_hover_text(&diagnostic.repair);
+            }
+        }
+        Err(error) => {
+            ui.label(
+                egui::RichText::new("Animation manifest unavailable")
+                    .small()
+                    .color(ERROR),
+            )
+            .on_hover_text(error);
+        }
+    }
+}
+
+fn manifest_for_actor(world: &World, entity: Entity) -> Result<AnimationManifest, String> {
+    let model = world
+        .get::<ModelRef>(entity)
+        .ok_or_else(|| "actor has no ModelRef".to_string())?;
+    let registry = world
+        .get_resource::<AssetRegistry>()
+        .ok_or_else(|| "asset registry is unavailable".to_string())?;
+    let normalized = model.path.trim_start_matches("./");
+    let with_assets = (!normalized.starts_with("assets/")).then(|| format!("assets/{normalized}"));
+    let without_assets = normalized.strip_prefix("assets/");
+    let record = (!model.asset_id.trim().is_empty())
+        .then(|| find_asset_by_id(registry, &model.asset_id))
+        .flatten()
+        .or_else(|| find_asset_by_path(registry, normalized))
+        .or_else(|| {
+            with_assets
+                .as_deref()
+                .and_then(|path| find_asset_by_path(registry, path))
+        })
+        .or_else(|| without_assets.and_then(|path| find_asset_by_path(registry, path)))
+        .ok_or_else(|| format!("model `{}` is not indexed", model.path))?;
+    let path = record
+        .import_settings
+        .animation_manifest_path
+        .as_deref()
+        .ok_or_else(|| format!("model `{}` has no animation manifest", model.path))?;
+    load_animation_manifest(path)
+}
+
+fn referenced_clip_manifests(
+    world: &World,
+    controller: &AnimationControllerDesc,
+    primary: Option<&AnimationManifest>,
+) -> HashMap<String, AnimationManifest> {
+    let Some(registry) = world.get_resource::<AssetRegistry>() else {
+        return HashMap::new();
+    };
+    let primary_id = primary.map(|manifest| manifest.asset_id.as_str());
+    let mut manifests = HashMap::new();
+    for asset_id in controller
+        .states
+        .iter()
+        .map(|state| state.clip.asset_id.as_str())
+        .filter(|asset_id| !asset_id.trim().is_empty() && Some(*asset_id) != primary_id)
+    {
+        if manifests.contains_key(asset_id) {
+            continue;
+        }
+        let Some(record) = find_asset_by_id(registry, asset_id) else {
+            continue;
+        };
+        let Some(path) = record.import_settings.animation_manifest_path.as_deref() else {
+            continue;
+        };
+        if let Ok(manifest) = load_animation_manifest(path) {
+            manifests.insert(asset_id.to_string(), manifest);
+        }
+    }
+    manifests
+}
+
+fn controller_from_manifest(manifest: &AnimationManifest) -> AnimationControllerDesc {
+    let skeleton = manifest
+        .skeletons
+        .first()
+        .map(|record| skeleton_ref(manifest, record));
+    let clip = preferred_clip(manifest, skeleton.as_ref());
+    let states = clip
+        .map(|clip| {
+            let id = unique_state_id(&clip.label, std::iter::empty::<&str>());
+            vec![AnimationStateDesc {
+                id,
+                label: clip.label.clone(),
+                clip: clip_ref(manifest, clip),
+                ..Default::default()
+            }]
+        })
+        .unwrap_or_default();
+    let default_state = states
+        .first()
+        .map(|state| state.id.clone())
+        .unwrap_or_default();
+    AnimationControllerDesc {
+        skeleton,
+        states,
+        default_state,
+        ..Default::default()
+    }
+}
+
+fn skeleton_ref(
+    manifest: &AnimationManifest,
+    skeleton: &AnimationSkeletonRecord,
+) -> EditorAssetRef {
+    EditorAssetRef::new(
+        manifest.asset_id.clone(),
+        skeleton.id.clone(),
+        skeleton.label.clone(),
+    )
+    .with_source_path(manifest.source.path.clone())
+}
+
+fn clip_ref(manifest: &AnimationManifest, clip: &AnimationClipRecord) -> EditorAssetRef {
+    EditorAssetRef::new(
+        manifest.asset_id.clone(),
+        clip.id.clone(),
+        clip.label.clone(),
+    )
+    .with_source_path(manifest.source.path.clone())
+}
+
+fn clip_for_ref<'a>(
+    manifest: &'a AnimationManifest,
+    reference: &EditorAssetRef,
+) -> Option<&'a AnimationClipRecord> {
+    if manifest.asset_id != reference.asset_id {
+        return None;
+    }
+    manifest
+        .clips
+        .iter()
+        .find(|clip| clip.id == reference.sub_asset_id)
+}
+
+fn resolved_clip_for_ref<'a>(
+    primary: &'a AnimationManifest,
+    referenced: &'a HashMap<String, AnimationManifest>,
+    reference: &EditorAssetRef,
+) -> Option<&'a AnimationClipRecord> {
+    if primary.asset_id == reference.asset_id {
+        clip_for_ref(primary, reference)
+    } else {
+        referenced
+            .get(&reference.asset_id)
+            .and_then(|manifest| clip_for_ref(manifest, reference))
+    }
+}
+
+fn preferred_clip<'a>(
+    manifest: &'a AnimationManifest,
+    skeleton: Option<&EditorAssetRef>,
+) -> Option<&'a AnimationClipRecord> {
+    manifest
+        .clips
+        .iter()
+        .find(|clip| clip_compatibility(manifest, skeleton, clip) == ClipCompatibility::Compatible)
+        .or_else(|| {
+            manifest.clips.iter().find(|clip| {
+                clip_compatibility(manifest, skeleton, clip) == ClipCompatibility::Unknown
+            })
+        })
+}
+
+fn clip_compatibility(
+    manifest: &AnimationManifest,
+    skeleton: Option<&EditorAssetRef>,
+    clip: &AnimationClipRecord,
+) -> ClipCompatibility {
+    let Some(skeleton) = skeleton else {
+        return ClipCompatibility::Unknown;
+    };
+    let Some(skeleton) = manifest
+        .skeletons
+        .iter()
+        .find(|record| record.id == skeleton.sub_asset_id)
+    else {
+        return ClipCompatibility::Unknown;
+    };
+    let Some(target) = clip.target_skeleton_signature.as_ref() else {
+        return ClipCompatibility::Unknown;
+    };
+    if target == &skeleton.signature {
+        ClipCompatibility::Compatible
+    } else {
+        ClipCompatibility::Mismatch
+    }
+}
+
+fn unique_state_id<'a>(label: &str, existing: impl Iterator<Item = &'a str>) -> String {
+    let existing = existing.collect::<Vec<_>>();
+    let mut base = String::new();
+    for character in label.chars() {
+        if character.is_ascii_alphanumeric() {
+            base.push(character.to_ascii_lowercase());
+        } else if !base.ends_with('_') {
+            base.push('_');
+        }
+    }
+    let base = base.trim_matches('_');
+    let base = if base.is_empty() { "state" } else { base };
+    if !existing.contains(&base) {
+        return base.to_string();
+    }
+    (2..)
+        .map(|suffix| format!("{base}_{suffix}"))
+        .find(|candidate| !existing.iter().any(|id| *id == candidate))
+        .expect("unbounded state ID suffix search must find an ID")
+}
+
+fn state_display_name(state: &AnimationStateDesc) -> &str {
+    if state.label.trim().is_empty() {
+        state.id.as_str()
+    } else {
+        state.label.as_str()
+    }
+}
+
+fn set_status(world: &mut World, status: impl Into<String>) {
+    if let Some(mut scene_io) = world.get_resource_mut::<crate::scene_io::SceneIo>() {
+        scene_io.set_status(status);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use shared::{AnimationManifestSource, AnimationSkeletonSignature, AnimationSourceFingerprint};
+
+    fn manifest() -> AnimationManifest {
+        let signature = AnimationSkeletonSignature::new("rig-a");
+        AnimationManifest {
+            schema_version: 1,
+            asset_id: "model-id".into(),
+            label: "Robot".into(),
+            source: AnimationManifestSource {
+                path: "assets/models/robot.glb".into(),
+                format: "glb".into(),
+                fingerprint: AnimationSourceFingerprint {
+                    byte_len: 42,
+                    modified_unix_secs: 1,
+                    content_hash: "hash".into(),
+                },
+                dependencies: Vec::new(),
+            },
+            runtime_supported: true,
+            skeletons: vec![AnimationSkeletonRecord {
+                id: "animation:skeleton:0:rig".into(),
+                label: "Rig".into(),
+                source_index: 0,
+                signature: signature.clone(),
+                joint_paths: vec!["Root".into()],
+            }],
+            clips: vec![
+                AnimationClipRecord {
+                    id: "animation:clip:0:idle".into(),
+                    label: "Idle Loop".into(),
+                    source_index: 0,
+                    duration_seconds: 2.0,
+                    target_skeleton_signature: Some(signature),
+                    events: Vec::new(),
+                },
+                AnimationClipRecord {
+                    id: "animation:clip:1:other".into(),
+                    label: "Other".into(),
+                    source_index: 1,
+                    duration_seconds: 1.0,
+                    target_skeleton_signature: Some(AnimationSkeletonSignature::new("rig-b")),
+                    events: Vec::new(),
+                },
+            ],
+            diagnostics: Vec::new(),
+        }
+    }
+
+    #[test]
+    fn manifest_defaults_select_a_compatible_rig_and_clip() {
+        let manifest = manifest();
+        let controller = controller_from_manifest(&manifest);
+        assert_eq!(controller.skeleton.as_ref().unwrap().label, "Rig");
+        assert_eq!(controller.states.len(), 1);
+        assert_eq!(controller.states[0].id, "idle_loop");
+        assert_eq!(controller.default_state, "idle_loop");
+        assert_eq!(
+            controller.states[0].clip.source_path.as_deref(),
+            Some("assets/models/robot.glb")
+        );
+    }
+
+    #[test]
+    fn state_ids_are_stable_and_unique() {
+        assert_eq!(
+            unique_state_id("Idle Loop", std::iter::empty()),
+            "idle_loop"
+        );
+        assert_eq!(
+            unique_state_id("Idle Loop", ["idle_loop"].into_iter()),
+            "idle_loop_2"
+        );
+        assert_eq!(
+            unique_state_id("---", ["state", "state_2"].into_iter()),
+            "state_3"
+        );
+    }
+
+    #[test]
+    fn compatibility_distinguishes_matching_and_foreign_rigs() {
+        let manifest = manifest();
+        let skeleton = skeleton_ref(&manifest, &manifest.skeletons[0]);
+        assert_eq!(
+            clip_compatibility(&manifest, Some(&skeleton), &manifest.clips[0]),
+            ClipCompatibility::Compatible
+        );
+        assert_eq!(
+            clip_compatibility(&manifest, Some(&skeleton), &manifest.clips[1]),
+            ClipCompatibility::Mismatch
+        );
+        assert_eq!(
+            clip_compatibility(&manifest, None, &manifest.clips[0]),
+            ClipCompatibility::Unknown
+        );
+    }
+
+    #[test]
+    fn clip_lookup_uses_stable_parent_asset_identity() {
+        let primary = manifest();
+        let mut foreign = manifest();
+        foreign.asset_id = "foreign-model-id".into();
+        foreign.clips[0].label = "Foreign Idle".into();
+        let reference = EditorAssetRef::new(
+            foreign.asset_id.clone(),
+            foreign.clips[0].id.clone(),
+            foreign.clips[0].label.clone(),
+        );
+        let referenced = HashMap::from([(foreign.asset_id.clone(), foreign)]);
+
+        assert!(clip_for_ref(&primary, &reference).is_none());
+        assert_eq!(
+            resolved_clip_for_ref(&primary, &referenced, &reference)
+                .map(|clip| clip.label.as_str()),
+            Some("Foreign Idle")
+        );
+    }
+
+    #[test]
+    fn preview_does_not_dirty_authored_data_or_history() {
+        let mut world = World::new();
+        world.init_resource::<game::animation::AnimationPreviewRuntime>();
+        world.init_resource::<crate::history::EditorHistory>();
+        world.init_resource::<crate::scene_io::SceneIo>();
+        let controller = controller_from_manifest(&manifest());
+        let actor = world.spawn(controller.clone()).id();
+
+        game::animation::set_animation_preview(
+            &mut world,
+            game::animation::AnimationPreviewRequest {
+                actor,
+                state_id: controller.default_state.clone(),
+                seek_seconds: Some(0.5),
+                playing: true,
+            },
+        )
+        .unwrap();
+        game::animation::stop_animation_preview(&mut world);
+
+        assert_eq!(
+            world.get::<AnimationControllerDesc>(actor),
+            Some(&controller)
+        );
+        assert_eq!(
+            world
+                .resource::<crate::history::EditorHistory>()
+                .undo_depth(),
+            0
+        );
+        assert!(!world.resource::<crate::scene_io::SceneIo>().dirty);
+    }
+}
diff --git a/crates/editor/src/ui/asset_browser/panel.rs b/crates/editor/src/ui/asset_browser/panel.rs
index 30eba3e..eef2988 100644
--- a/crates/editor/src/ui/asset_browser/panel.rs
+++ b/crates/editor/src/ui/asset_browser/panel.rs
@@ -29,16 +29,18 @@ use crate::asset_db::{
     find_asset_by_path, find_asset_mut_by_path, save_registry, update_import_settings,
     ImportSettings, MaterialImportPolicy, ModelHierarchyMode, ModelPlacementMode,
 };
+use crate::assets::animation::load_animation_manifest;
 use crate::assets::operators::{
-    apply_material_operator, apply_texture_operator, place_asset_operator, place_subasset_operator,
+    apply_material_operator, apply_texture_operator, assign_animation_clip_operator,
+    place_asset_operator, place_subasset_operator,
 };
 use crate::assets::static_mesh::{
     load_static_mesh_manifest, material_id_from_label, part_id_from_label,
-    refresh_static_mesh_artifact,
 };
 use crate::assets::{
     asset_cache_key, draw_asset_cell_with, invalidate_on_catalog_refresh, kind_icon,
-    prefetch_folder_thumbnails, AssetThumbnailCache, ThumbnailCacheSnapshot, ThumbnailStudio,
+    prefetch_folder_thumbnails, refresh_model_artifacts, AssetThumbnailCache,
+    ThumbnailCacheSnapshot, ThumbnailStudio,
 };
 use crate::ui::helpers::asset_label;
 use crate::ui::theme::{panel_heading, ACCENT, BORDER, ELEVATED_BG, TEXT, TEXT_DIM, WIDGET_BG};
@@ -81,6 +83,7 @@ struct EmbeddedAsset {
     thumbnail_key: String,
     mesh_label: Option<String>,
     material_label: Option<String>,
+    requires_scene_instance: bool,
 }
 
 fn fit_width(ui: &egui::Ui, min: f32, max: f32) -> f32 {
@@ -343,115 +346,188 @@ fn embedded_assets_for_asset(world: &World, asset: &EditorAsset) -> Vec<Embedded
     else {
         return Vec::new();
     };
-    let Some(manifest_path) = record.import_settings.static_mesh_manifest_path.as_deref() else {
-        return Vec::new();
-    };
-    let Ok(manifest) = load_static_mesh_manifest(manifest_path) else {
-        return Vec::new();
-    };
-
     let mut embedded = Vec::new();
-    for part in &manifest.parts {
-        let mesh_id = part_effective_id(part);
-        let material_label = part.material_label.clone();
-        embedded.push(EmbeddedAsset {
-            selection: AssetSelection::SubAsset {
-                parent_path: parent_path.clone(),
-                sub_asset_id: mesh_id,
+    let static_manifest = record
+        .import_settings
+        .static_mesh_manifest_path
+        .as_deref()
+        .and_then(|path| load_static_mesh_manifest(path).ok());
+    let skinned_primitives = crate::assets::gltf_skinned_primitive_labels(parent_path.as_str());
+    if let Some(manifest) = static_manifest.as_ref() {
+        for part in &manifest.parts {
+            let mesh_id = part_effective_id(part);
+            let material_label = part.material_label.clone();
+            let requires_scene_instance = skinned_primitives.contains(&part.mesh_label);
+            embedded.push(EmbeddedAsset {
+                selection: AssetSelection::SubAsset {
+                    parent_path: parent_path.clone(),
+                    sub_asset_id: mesh_id,
+                    label: part.name.clone(),
+                    kind: AssetSubAssetKind::Mesh,
+                    source_path: None,
+                },
                 label: part.name.clone(),
                 kind: AssetSubAssetKind::Mesh,
-                source_path: None,
-            },
-            label: part.name.clone(),
-            kind: AssetSubAssetKind::Mesh,
-            detail: part
-                .source_mesh
-                .clone()
-                .unwrap_or_else(|| part.mesh_label.clone()),
-            texture_path: None,
-            thumbnail_key: subasset_thumbnail_key(
-                parent_path,
-                AssetSubAssetKind::Mesh,
-                &part_effective_id(part),
-            ),
-            mesh_label: Some(part.mesh_label.clone()),
-            material_label,
-        });
-    }
-
-    let mut material_ids = HashSet::new();
-    for part in &manifest.parts {
-        let Some(material_id) = part_effective_material_id(part) else {
-            continue;
-        };
-        if !material_ids.insert(material_id.clone()) {
-            continue;
+                detail: if requires_scene_instance {
+                    "Skinned | place model or animation clip".to_string()
+                } else {
+                    part.source_mesh
+                        .clone()
+                        .unwrap_or_else(|| part.mesh_label.clone())
+                },
+                texture_path: None,
+                thumbnail_key: subasset_thumbnail_key(
+                    parent_path,
+                    AssetSubAssetKind::Mesh,
+                    &part_effective_id(part),
+                ),
+                mesh_label: Some(part.mesh_label.clone()),
+                material_label,
+                requires_scene_instance,
+            });
         }
-        let label = if part.material_slot_name.trim().is_empty() {
-            part.material_label
-                .clone()
-                .unwrap_or_else(|| "Source Material".to_string())
-        } else {
-            part.material_slot_name.clone()
-        };
-        embedded.push(EmbeddedAsset {
-            selection: AssetSelection::SubAsset {
-                parent_path: parent_path.clone(),
-                sub_asset_id: material_id,
-                label: label.clone(),
+
+        let mut material_ids = HashSet::new();
+        for part in &manifest.parts {
+            let Some(material_id) = part_effective_material_id(part) else {
+                continue;
+            };
+            if !material_ids.insert(material_id.clone()) {
+                continue;
+            }
+            let label = if part.material_slot_name.trim().is_empty() {
+                part.material_label
+                    .clone()
+                    .unwrap_or_else(|| "Source Material".to_string())
+            } else {
+                part.material_slot_name.clone()
+            };
+            embedded.push(EmbeddedAsset {
+                selection: AssetSelection::SubAsset {
+                    parent_path: parent_path.clone(),
+                    sub_asset_id: material_id,
+                    label: label.clone(),
+                    kind: AssetSubAssetKind::Material,
+                    source_path: None,
+                },
+                label,
                 kind: AssetSubAssetKind::Material,
-                source_path: None,
-            },
-            label,
-            kind: AssetSubAssetKind::Material,
-            detail: "Embedded source material".to_string(),
-            texture_path: None,
-            thumbnail_key: subasset_thumbnail_key(
-                parent_path,
-                AssetSubAssetKind::Material,
-                &part_effective_material_id(part).unwrap_or_else(|| {
-                    material_id_from_label(
-                        part.material_label
-                            .as_deref()
-                            .unwrap_or(&part.material_slot_name),
-                    )
-                }),
-            ),
-            mesh_label: None,
-            material_label: part.material_label.clone(),
-        });
+                detail: "Embedded source material".to_string(),
+                texture_path: None,
+                thumbnail_key: subasset_thumbnail_key(
+                    parent_path,
+                    AssetSubAssetKind::Material,
+                    &part_effective_material_id(part).unwrap_or_else(|| {
+                        material_id_from_label(
+                            part.material_label
+                                .as_deref()
+                                .unwrap_or(&part.material_slot_name),
+                        )
+                    }),
+                ),
+                mesh_label: None,
+                material_label: part.material_label.clone(),
+                requires_scene_instance: false,
+            });
+        }
+
+        let mut texture_paths = HashSet::new();
+        for dependency in &manifest.source.dependencies {
+            if !is_texture_path(dependency) || !texture_paths.insert(dependency.clone()) {
+                continue;
+            }
+            let label = Path::new(dependency)
+                .file_stem()
+                .and_then(|stem| stem.to_str())
+                .unwrap_or(dependency)
+                .to_string();
+            embedded.push(EmbeddedAsset {
+                selection: AssetSelection::SubAsset {
+                    parent_path: parent_path.clone(),
+                    sub_asset_id: format!("texture:{}", stable_subasset_slug(dependency)),
+                    label: label.clone(),
+                    kind: AssetSubAssetKind::Texture,
+                    source_path: Some(dependency.clone()),
+                },
+                label,
+                kind: AssetSubAssetKind::Texture,
+                detail: dependency.clone(),
+                texture_path: Some(dependency.clone()),
+                thumbnail_key: subasset_thumbnail_key(
+                    parent_path,
+                    AssetSubAssetKind::Texture,
+                    &stable_subasset_slug(dependency),
+                ),
+                mesh_label: None,
+                material_label: None,
+                requires_scene_instance: false,
+            });
+        }
     }
 
-    let mut texture_paths = HashSet::new();
-    for dependency in &manifest.source.dependencies {
-        if !is_texture_path(dependency) || !texture_paths.insert(dependency.clone()) {
-            continue;
+    let animation_manifest = record
+        .import_settings
+        .animation_manifest_path
+        .as_deref()
+        .and_then(|path| load_animation_manifest(path).ok());
+    if let Some(manifest) = animation_manifest {
+        for skeleton in manifest.skeletons {
+            let signature = skeleton.signature.0;
+            let signature_short = signature.get(..8).unwrap_or(&signature);
+            embedded.push(EmbeddedAsset {
+                selection: AssetSelection::SubAsset {
+                    parent_path: parent_path.clone(),
+                    sub_asset_id: skeleton.id.clone(),
+                    label: skeleton.label.clone(),
+                    kind: AssetSubAssetKind::Skeleton,
+                    source_path: Some(parent_path.clone()),
+                },
+                label: skeleton.label,
+                kind: AssetSubAssetKind::Skeleton,
+                detail: format!(
+                    "{} joints | rig {}",
+                    skeleton.joint_paths.len(),
+                    signature_short
+                ),
+                texture_path: None,
+                thumbnail_key: subasset_thumbnail_key(
+                    parent_path,
+                    AssetSubAssetKind::Skeleton,
+                    &skeleton.id,
+                ),
+                mesh_label: None,
+                material_label: None,
+                requires_scene_instance: false,
+            });
+        }
+        for clip in manifest.clips {
+            let event_suffix = if clip.events.is_empty() {
+                String::new()
+            } else {
+                format!(" | {} events", clip.events.len())
+            };
+            embedded.push(EmbeddedAsset {
+                selection: AssetSelection::SubAsset {
+                    parent_path: parent_path.clone(),
+                    sub_asset_id: clip.id.clone(),
+                    label: clip.label.clone(),
+                    kind: AssetSubAssetKind::AnimationClip,
+                    source_path: Some(parent_path.clone()),
+                },
+                label: clip.label,
+                kind: AssetSubAssetKind::AnimationClip,
+                detail: format!("{:.2}s{event_suffix}", clip.duration_seconds),
+                texture_path: None,
+                thumbnail_key: subasset_thumbnail_key(
+                    parent_path,
+                    AssetSubAssetKind::AnimationClip,
+                    &clip.id,
+                ),
+                mesh_label: None,
+                material_label: None,
+                requires_scene_instance: false,
+            });
         }
-        let label = Path::new(dependency)
-            .file_stem()
-            .and_then(|stem| stem.to_str())
-            .unwrap_or(dependency)
-            .to_string();
-        embedded.push(EmbeddedAsset {
-            selection: AssetSelection::SubAsset {
-                parent_path: parent_path.clone(),
-                sub_asset_id: format!("texture:{}", stable_subasset_slug(dependency)),
-                label: label.clone(),
-                kind: AssetSubAssetKind::Texture,
-                source_path: Some(dependency.clone()),
-            },
-            label,
-            kind: AssetSubAssetKind::Texture,
-            detail: dependency.clone(),
-            texture_path: Some(dependency.clone()),
-            thumbnail_key: subasset_thumbnail_key(
-                parent_path,
-                AssetSubAssetKind::Texture,
-                &stable_subasset_slug(dependency),
-            ),
-            mesh_label: None,
-            material_label: None,
-        });
     }
 
     embedded
@@ -566,6 +642,7 @@ fn asset_toolbar(world: &mut World, ui: &mut egui::Ui) {
                     AssetKindFilter::Material,
                     "Materials",
                 );
+                ui.selectable_value(&mut state.kind_filter, AssetKindFilter::Audio, "Audio");
                 ui.selectable_value(&mut state.kind_filter, AssetKindFilter::Level, "Levels");
                 ui.selectable_value(&mut state.kind_filter, AssetKindFilter::Prefab, "Prefabs");
                 ui.selectable_value(
@@ -712,6 +789,9 @@ fn breadcrumb(world: &mut World, ui: &mut egui::Ui, current_folder: &str) {
 
 fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &SelectedEntities) {
     let selection = world.resource::<EditorAssets>().selected.clone();
+    let selected_embedded = selection
+        .as_ref()
+        .and_then(|selection| embedded_asset_for_selection(world, selection));
     if let Some(AssetSelection::SubAsset { label, kind, .. }) = selection.clone() {
         ui.add(
             egui::Label::new(format!(
@@ -723,7 +803,14 @@ fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &Se
         );
         ui.horizontal_wrapped(|ui| match kind {
             AssetSubAssetKind::Mesh => {
-                if ui.button("Place At Origin").clicked() {
+                if selected_embedded
+                    .as_ref()
+                    .is_some_and(|embedded| embedded.requires_scene_instance)
+                {
+                    ui.small(
+                        egui::RichText::new("Place the model or an animation clip").color(TEXT_DIM),
+                    );
+                } else if ui.button("Place At Origin").clicked() {
                     if let Some(selection) = selection.as_ref() {
                         place_subasset_operator(world, selection.clone(), Vec3::ZERO);
                     }
@@ -739,6 +826,30 @@ fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &Se
             AssetSubAssetKind::Material => {
                 ui.small(egui::RichText::new("Embedded source material").color(TEXT_DIM));
             }
+            AssetSubAssetKind::Skeleton => {
+                ui.small(egui::RichText::new("Inspect-only rig metadata").color(TEXT_DIM));
+            }
+            AssetSubAssetKind::AnimationClip => {
+                let animated_actor = selected_entities
+                    .as_slice()
+                    .iter()
+                    .copied()
+                    .find(|entity| world.get::<shared::ModelRef>(*entity).is_some());
+                let action = if animated_actor.is_some() {
+                    "Assign To Selected Actor"
+                } else {
+                    "Create Animated Actor"
+                };
+                if ui.button(action).clicked() {
+                    if let Some(selection) = selection.as_ref() {
+                        if let Some(entity) = animated_actor {
+                            assign_animation_clip_operator(world, selection.clone(), entity);
+                        } else {
+                            place_subasset_operator(world, selection.clone(), Vec3::ZERO);
+                        }
+                    }
+                }
+            }
         });
     } else if let Some(asset) = world.resource::<EditorAssets>().selected_asset().cloned() {
         ui.add(egui::Label::new(format!("Selected: {}", asset_label(&asset))).truncate());
@@ -753,12 +864,15 @@ fn selection_footer(world: &mut World, ui: &mut egui::Ui, selected_entities: &Se
                 EditorAssetKind::Primitive(_)
                     | EditorAssetKind::Light(_)
                     | EditorAssetKind::Model
+                    | EditorAssetKind::AudioClip
                     | EditorAssetKind::Prefab
-                    | EditorAssetKind::Level
             ) && ui.button("Place At Origin").clicked()
             {
                 place_asset_operator(world, asset.clone(), Vec3::ZERO);
             }
+            if matches!(asset.kind, EditorAssetKind::Level) && ui.button("Open Scene").clicked() {
+                open_level_asset(world, &asset);
+            }
         });
     } else {
         ui.label(egui::RichText::new("No asset selected").color(TEXT_DIM));
@@ -1143,6 +1257,7 @@ fn prefetch_embedded_thumbnails(
                             parent_path.clone(),
                             mesh_label,
                             embedded_asset.material_label.clone(),
+                            embedded_asset.requires_scene_instance,
                             &mut studio,
                         );
                     }
@@ -1167,6 +1282,7 @@ fn prefetch_embedded_thumbnails(
                             &asset_server,
                         );
                     }
+                    AssetSubAssetKind::Skeleton | AssetSubAssetKind::AnimationClip => {}
                 }
             }
         });
@@ -1201,6 +1317,13 @@ fn draw_embedded_asset_cell(
     let thumb_size = thumbnail_size.clamp(44.0, 64.0);
     let cell_size = egui::vec2(104.0, thumb_size + 50.0);
     let (rect, response) = ui.allocate_exact_size(cell_size, egui::Sense::click_and_drag());
+    let response = if embedded.requires_scene_instance {
+        response.on_hover_text(
+            "Skinned primitives require their model hierarchy. Place the model or an animation clip instead.",
+        )
+    } else {
+        response
+    };
     let fill = if selected {
         crate::ui::theme::SELECTION_BG_MUTED
     } else if response.hovered() {
@@ -1277,7 +1400,10 @@ fn draw_embedded_asset_cell(
             .resource_mut::<EditorAssets>()
             .select(embedded.selection.clone());
     }
-    if response.drag_started() {
+    if response.drag_started()
+        && embedded.kind != AssetSubAssetKind::Skeleton
+        && !embedded.requires_scene_instance
+    {
         world
             .resource_mut::<EditorAssets>()
             .start_drag(embedded.selection.clone());
@@ -1294,7 +1420,10 @@ fn compact_subasset_label(embedded: &EmbeddedAsset) -> String {
             .split_once(" / ")
             .map(|(head, _)| head)
             .unwrap_or(&embedded.label),
-        AssetSubAssetKind::Material | AssetSubAssetKind::Texture => embedded.label.as_str(),
+        AssetSubAssetKind::Material
+        | AssetSubAssetKind::Texture
+        | AssetSubAssetKind::Skeleton
+        | AssetSubAssetKind::AnimationClip => embedded.label.as_str(),
     };
     compact_text(base, 16)
 }
@@ -1339,6 +1468,8 @@ fn subasset_icon(kind: AssetSubAssetKind) -> Icon {
         AssetSubAssetKind::Mesh => icons::CUBE,
         AssetSubAssetKind::Material => icons::PALETTE,
         AssetSubAssetKind::Texture => icons::IMAGE,
+        AssetSubAssetKind::Skeleton => icons::BONE,
+        AssetSubAssetKind::AnimationClip => icons::FILM_STRIP,
     }
 }
 
@@ -1347,6 +1478,8 @@ fn subasset_kind_label(kind: AssetSubAssetKind) -> &'static str {
         AssetSubAssetKind::Mesh => "Mesh",
         AssetSubAssetKind::Material => "Material",
         AssetSubAssetKind::Texture => "Texture",
+        AssetSubAssetKind::Skeleton => "Skeleton",
+        AssetSubAssetKind::AnimationClip => "Animation Clip",
     }
 }
 
@@ -1741,6 +1874,39 @@ fn top_level_asset_details_panel(
             ui.label(panel_heading("Material"));
             material_asset_editor(world, ui, asset, path);
         }
+        if matches!(asset.kind, EditorAssetKind::AudioClip) {
+            detail_row(ui, "Format", audio_format_label(path));
+            let previewing = world
+                .resource::<crate::play::audio_preview::AudioPreviewState>()
+                .clip_path
+                .as_deref()
+                == Some(path);
+            ui.horizontal_wrapped(|ui| {
+                if ui
+                    .add_enabled(
+                        !previewing,
+                        egui::Button::new(format!("{} Audition", icons::PLAY.as_str())),
+                    )
+                    .clicked()
+                {
+                    if let Err(error) =
+                        crate::play::audio_preview::audition_audio_asset(world, asset)
+                    {
+                        world.resource_mut::<SceneIo>().status =
+                            format!("Audio audition failed: {error}");
+                    }
+                }
+                if ui
+                    .add_enabled(
+                        previewing,
+                        egui::Button::new(format!("{} Stop", icons::STOP.as_str())),
+                    )
+                    .clicked()
+                {
+                    crate::play::audio_preview::stop_audio_preview(world);
+                }
+            });
+        }
     }
 
     ui.separator();
@@ -1804,7 +1970,14 @@ fn subasset_details_panel(
     ui.separator();
     match embedded.kind {
         AssetSubAssetKind::Mesh => {
-            if ui.button("Place At Origin").clicked() {
+            if embedded.requires_scene_instance {
+                ui.small(
+                    egui::RichText::new(
+                        "This skinned primitive needs its source hierarchy. Place the model or an animation clip instead.",
+                    )
+                    .color(TEXT_DIM),
+                );
+            } else if ui.button("Place At Origin").clicked() {
                 place_subasset_operator(world, selection.clone(), Vec3::ZERO);
             }
         }
@@ -1825,6 +1998,31 @@ fn subasset_details_panel(
                 .color(TEXT_DIM),
             );
         }
+        AssetSubAssetKind::Skeleton => {
+            ui.small(
+                egui::RichText::new("Skeleton metadata is generated from the model source.")
+                    .color(TEXT_DIM),
+            );
+        }
+        AssetSubAssetKind::AnimationClip => {
+            let animated_actor = selected_entities
+                .as_slice()
+                .iter()
+                .copied()
+                .find(|entity| world.get::<shared::ModelRef>(*entity).is_some());
+            let action = if animated_actor.is_some() {
+                "Assign To Selected Actor"
+            } else {
+                "Create Animated Actor"
+            };
+            if ui.button(action).clicked() {
+                if let Some(entity) = animated_actor {
+                    assign_animation_clip_operator(world, selection.clone(), entity);
+                } else {
+                    place_subasset_operator(world, selection.clone(), Vec3::ZERO);
+                }
+            }
+        }
     }
     if ui.button("Select Parent Asset").clicked() {
         world
@@ -1852,12 +2050,15 @@ fn asset_action_buttons(
             EditorAssetKind::Primitive(_)
                 | EditorAssetKind::Light(_)
                 | EditorAssetKind::Model
+                | EditorAssetKind::AudioClip
                 | EditorAssetKind::Prefab
-                | EditorAssetKind::Level
         ) && ui.button("Place At Origin").clicked()
         {
             place_asset_operator(world, asset.clone(), Vec3::ZERO);
         }
+        if matches!(asset.kind, EditorAssetKind::Level) && ui.button("Open Scene").clicked() {
+            open_level_asset(world, asset);
+        }
         if matches!(asset.kind, EditorAssetKind::Model)
             && has_embedded_assets(world, asset)
             && ui.button("Toggle Contents").clicked()
@@ -1875,6 +2076,13 @@ fn asset_action_buttons(
     });
 }
 
+fn open_level_asset(world: &mut World, asset: &EditorAsset) {
+    let Some(path) = asset.path.as_deref() else {
+        return;
+    };
+    world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::OpenPath(PathBuf::from(path)));
+}
+
 fn import_settings_editor(
     world: &mut World,
     ui: &mut egui::Ui,
@@ -1989,8 +2197,8 @@ fn apply_import_settings(
         update_import_settings(&mut registry, path, settings);
         if matches!(asset.kind, EditorAssetKind::Model) {
             if let Some(record) = find_asset_mut_by_path(&mut registry, path) {
-                if let Err(error) = refresh_static_mesh_artifact(record) {
-                    status = format!("Static mesh refresh failed for {}: {error}", asset.label);
+                if let Err(error) = refresh_model_artifacts(record) {
+                    status = format!("Model artifact refresh failed for {}: {error}", asset.label);
                     warn!("{status}");
                 }
             }
@@ -2705,6 +2913,7 @@ fn asset_matches_kind_filter(asset: &EditorAsset, filter: AssetKindFilter) -> bo
         AssetKindFilter::Model => matches!(asset.kind, EditorAssetKind::Model),
         AssetKindFilter::Texture => matches!(asset.kind, EditorAssetKind::Texture),
         AssetKindFilter::Material => matches!(asset.kind, EditorAssetKind::Material),
+        AssetKindFilter::Audio => matches!(asset.kind, EditorAssetKind::AudioClip),
         AssetKindFilter::Level => matches!(asset.kind, EditorAssetKind::Level),
         AssetKindFilter::Prefab => matches!(asset.kind, EditorAssetKind::Prefab),
         AssetKindFilter::Builtin => asset.path.is_none(),
@@ -2717,6 +2926,7 @@ fn kind_filter_label(filter: AssetKindFilter) -> &'static str {
         AssetKindFilter::Model => "Models",
         AssetKindFilter::Texture => "Textures",
         AssetKindFilter::Material => "Materials",
+        AssetKindFilter::Audio => "Audio",
         AssetKindFilter::Level => "Levels",
         AssetKindFilter::Prefab => "Prefabs",
         AssetKindFilter::Builtin => "Built-ins",
@@ -2739,6 +2949,7 @@ fn kind_label(kind: &EditorAssetKind) -> &'static str {
         EditorAssetKind::Model => "Model",
         EditorAssetKind::Texture => "Texture",
         EditorAssetKind::Material => "Material",
+        EditorAssetKind::AudioClip => "Audio Clip",
         EditorAssetKind::Level => "Level",
         EditorAssetKind::Prefab => "Prefab",
         EditorAssetKind::PostProcessVolume => "Post Process Volume",
@@ -2752,6 +2963,22 @@ fn file_size(path: &str) -> Option<u64> {
     fs::metadata(path).ok().map(|metadata| metadata.len())
 }
 
+fn audio_format_label(path: &str) -> &'static str {
+    match Path::new(path)
+        .extension()
+        .and_then(|extension| extension.to_str())
+        .map(str::to_ascii_lowercase)
+        .as_deref()
+    {
+        Some("ogg" | "oga") => "Ogg audio",
+        Some("spx") => "Speex",
+        Some("wav") => "WAV",
+        Some("mp3") => "MP3",
+        Some("flac") => "FLAC",
+        _ => "Unknown",
+    }
+}
+
 fn modified_time(path: &str) -> Option<SystemTime> {
     fs::metadata(path)
         .ok()
@@ -2813,13 +3040,17 @@ fn asset_context_menu(
         EditorAssetKind::Primitive(_)
             | EditorAssetKind::Light(_)
             | EditorAssetKind::Model
+            | EditorAssetKind::AudioClip
             | EditorAssetKind::Prefab
-            | EditorAssetKind::Level
     ) && ui.button("Place at Origin").clicked()
     {
         place_asset_operator(world, asset.clone(), Vec3::ZERO);
         ui.close();
     }
+    if matches!(asset.kind, EditorAssetKind::Level) && ui.button("Open Scene").clicked() {
+        open_level_asset(world, asset);
+        ui.close();
+    }
     if matches!(asset.kind, EditorAssetKind::Model) && has_embedded_assets(world, asset) {
         let expanded = asset.path.as_deref().is_some_and(|path| {
             world
@@ -2888,7 +3119,12 @@ fn subasset_context_menu(
     }
     match embedded.kind {
         AssetSubAssetKind::Mesh => {
-            if ui.button("Place at Origin").clicked() {
+            if embedded.requires_scene_instance {
+                ui.label(
+                    egui::RichText::new("Skinned mesh: place parent model or animation clip")
+                        .color(TEXT_DIM),
+                );
+            } else if ui.button("Place at Origin").clicked() {
                 place_subasset_operator(world, embedded.selection.clone(), Vec3::ZERO);
                 ui.close();
             }
@@ -2906,8 +3142,35 @@ fn subasset_context_menu(
         AssetSubAssetKind::Material => {
             ui.label(egui::RichText::new("Embedded source material").color(TEXT_DIM));
         }
+        AssetSubAssetKind::Skeleton => {
+            ui.label(egui::RichText::new("Inspect-only rig metadata").color(TEXT_DIM));
+        }
+        AssetSubAssetKind::AnimationClip => {
+            let animated_actor = selected_entities
+                .as_slice()
+                .iter()
+                .copied()
+                .find(|entity| world.get::<shared::ModelRef>(*entity).is_some());
+            let action = if animated_actor.is_some() {
+                "Assign To Selected Actor"
+            } else {
+                "Create Animated Actor"
+            };
+            if ui.button(action).clicked() {
+                if let Some(entity) = animated_actor {
+                    assign_animation_clip_operator(world, embedded.selection.clone(), entity);
+                } else {
+                    place_subasset_operator(world, embedded.selection.clone(), Vec3::ZERO);
+                }
+                ui.close();
+            }
+        }
     }
-    if ui.button("Regenerate Thumbnail").clicked() {
+    if matches!(
+        embedded.kind,
+        AssetSubAssetKind::Mesh | AssetSubAssetKind::Material | AssetSubAssetKind::Texture
+    ) && ui.button("Regenerate Thumbnail").clicked()
+    {
         regenerate_subasset_thumbnail(world, embedded);
         ui.close();
     }
@@ -2969,6 +3232,7 @@ fn regenerate_subasset_thumbnail(world: &mut World, embedded: &EmbeddedAsset) {
                         parent_path.clone(),
                         mesh_label,
                         embedded.material_label.clone(),
+                        embedded.requires_scene_instance,
                         &mut studio,
                     );
                 });
@@ -2991,6 +3255,7 @@ fn regenerate_subasset_thumbnail(world: &mut World, embedded: &EmbeddedAsset) {
                     cache.request_texture(key.clone(), texture_path, &asset_server);
                 }
             }
+            AssetSubAssetKind::Skeleton | AssetSubAssetKind::AnimationClip => {}
         }
     });
     world.resource_mut::<SceneIo>().status =
@@ -3004,7 +3269,7 @@ fn reimport_asset(world: &mut World, asset: &EditorAsset) {
     let mut status = format!("Reimported {}", asset.label);
     if let Some(mut registry) = world.get_resource_mut::<crate::asset_db::AssetRegistry>() {
         if let Some(record) = find_asset_mut_by_path(&mut registry, path) {
-            if let Err(error) = refresh_static_mesh_artifact(record) {
+            if let Err(error) = refresh_model_artifacts(record) {
                 status = format!("Reimport failed for {}: {error}", asset.label);
                 warn!("{status}");
             }
@@ -3038,6 +3303,9 @@ fn build_delete_request(world: &World, asset: &EditorAsset) -> Option<AssetDelet
             if let Some(manifest) = record.import_settings.static_mesh_manifest_path {
                 files.push(manifest);
             }
+            if let Some(manifest) = record.import_settings.animation_manifest_path {
+                files.push(manifest);
+            }
             if !record.dependencies.is_empty() {
                 warnings.push(format!(
                     "{} imported dependencies will be kept because they may be shared.",
@@ -3190,3 +3458,35 @@ fn dedup_strings(values: &mut Vec<String>) {
     let mut seen = HashSet::new();
     values.retain(|value| seen.insert(value.clone()));
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn audio_filter_matches_only_audio_clips() {
+        let audio = EditorAsset {
+            label: "Impact".into(),
+            path: Some("assets/audio/impact.ogg".into()),
+            folder_path: "assets/audio".into(),
+            kind: EditorAssetKind::AudioClip,
+        };
+        let texture = EditorAsset {
+            kind: EditorAssetKind::Texture,
+            ..audio.clone()
+        };
+
+        assert!(asset_matches_kind_filter(&audio, AssetKindFilter::Audio));
+        assert!(!asset_matches_kind_filter(&texture, AssetKindFilter::Audio));
+        assert_eq!(kind_filter_label(AssetKindFilter::Audio), "Audio");
+    }
+
+    #[test]
+    fn audio_details_label_supported_formats() {
+        assert_eq!(audio_format_label("assets/audio/music.oga"), "Ogg audio");
+        assert_eq!(audio_format_label("assets/audio/voice.spx"), "Speex");
+        assert_eq!(audio_format_label("assets/audio/source.WAV"), "WAV");
+        assert_eq!(audio_format_label("assets/audio/source.mp3"), "MP3");
+        assert_eq!(audio_format_label("assets/audio/source.flac"), "FLAC");
+    }
+}
diff --git a/crates/editor/src/ui/asset_browser/state.rs b/crates/editor/src/ui/asset_browser/state.rs
index b029d4e..f0b2be4 100644
--- a/crates/editor/src/ui/asset_browser/state.rs
+++ b/crates/editor/src/ui/asset_browser/state.rs
@@ -28,6 +28,7 @@ pub(crate) enum AssetKindFilter {
     Model,
     Texture,
     Material,
+    Audio,
     Level,
     Prefab,
     Builtin,
diff --git a/crates/editor/src/ui/audio_inspector.rs b/crates/editor/src/ui/audio_inspector.rs
new file mode 100644
index 0000000..30ac0cb
--- /dev/null
+++ b/crates/editor/src/ui/audio_inspector.rs
@@ -0,0 +1,283 @@
+//! Audio source/listener authoring cards and transient audition controls.
+
+use bevy::prelude::*;
+use bevy_egui::egui;
+use egui_phosphor_icons::icons;
+use settings::{AUDIO_GAIN_DB_MAX, AUDIO_GAIN_DB_MIN};
+use shared::{
+    AudioListenerDesc, AudioRolloff, AudioSourceDesc, COMPONENT_AUDIO_LISTENER_DESC,
+    COMPONENT_AUDIO_SOURCE_DESC,
+};
+
+use crate::assets::{audio_clip_ref_for_asset, EditorAsset, EditorAssetKind, EditorAssets};
+use crate::history::{set_audio_listener_with_history, set_audio_source_with_history};
+use crate::play::audio_preview::{audition_audio_source, stop_audio_preview, AudioPreviewState};
+use crate::ui::inspector::{
+    apply_component_card_response, component_card, component_card_context, property_row,
+    ComponentCardOptions,
+};
+use crate::ui::theme::{SELECTION, TEXT_DIM};
+
+pub fn audio_source_inspector_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
+    let Some(mut source) = world.get::<AudioSourceDesc>(entity).cloned() else {
+        return;
+    };
+    let original = source.clone();
+    let audio_assets: Vec<EditorAsset> = world
+        .resource::<EditorAssets>()
+        .assets
+        .iter()
+        .filter(|asset| matches!(asset.kind, EditorAssetKind::AudioClip))
+        .cloned()
+        .collect();
+    let dragged_audio = world
+        .resource::<EditorAssets>()
+        .dragging_selection()
+        .and_then(|selection| {
+            world
+                .resource::<EditorAssets>()
+                .asset_for_selection(selection)
+        })
+        .filter(|asset| matches!(asset.kind, EditorAssetKind::AudioClip))
+        .cloned();
+    let buses = world
+        .resource::<settings::ProjectSettings>()
+        .audio
+        .buses
+        .clone();
+    let previewing = world.resource::<AudioPreviewState>().source == Some(entity);
+    let diagnostics = world
+        .resource::<game::audio::AudioRuntimeDiagnostics>()
+        .clone();
+    let mut pending_clip: Option<EditorAsset> = None;
+    let mut clear_clip = false;
+    let mut audition = false;
+    let mut stop = false;
+
+    let card = component_card_context(
+        world,
+        entity,
+        ComponentCardOptions::removable(
+            COMPONENT_AUDIO_SOURCE_DESC,
+            "Audio Source",
+            icons::SPEAKER_HIGH,
+        ),
+    );
+    let card_response = component_card(ui, &card, |ui| {
+        let clip_response = property_row(ui, "Clip", |ui| {
+            ui.horizontal_wrapped(|ui| {
+                let selected_text = source
+                    .clip
+                    .as_ref()
+                    .map(|clip| clip.label.as_str())
+                    .filter(|label| !label.trim().is_empty())
+                    .unwrap_or("None");
+                egui::ComboBox::from_id_salt(("audio_clip", entity))
+                    .selected_text(selected_text)
+                    .width(150.0)
+                    .show_ui(ui, |ui| {
+                        for asset in &audio_assets {
+                            let selected = source.clip.as_ref().is_some_and(|clip| {
+                                clip.source_path.as_deref() == asset.path.as_deref()
+                            });
+                            if ui.selectable_label(selected, &asset.label).clicked() {
+                                pending_clip = Some(asset.clone());
+                            }
+                        }
+                    });
+                if ui
+                    .add_enabled(source.clip.is_some(), egui::Button::new(icons::X.as_str()))
+                    .on_hover_text("Clear clip")
+                    .clicked()
+                {
+                    clear_clip = true;
+                }
+            })
+            .response
+        });
+        if dragged_audio.is_some() && clip_response.hovered() {
+            ui.painter().rect_stroke(
+                clip_response.rect.expand(3.0),
+                3.0,
+                egui::Stroke::new(1.5, SELECTION),
+                egui::StrokeKind::Outside,
+            );
+            if ui.input(|input| input.pointer.any_released()) {
+                pending_clip = dragged_audio.clone();
+            }
+        }
+
+        property_row(ui, "Playback", |ui| {
+            ui.horizontal_wrapped(|ui| {
+                if ui
+                    .add_enabled(
+                        source.clip.is_some() && !previewing,
+                        egui::Button::new(format!("{} Audition", icons::PLAY.as_str())),
+                    )
+                    .clicked()
+                {
+                    audition = true;
+                }
+                if ui
+                    .add_enabled(
+                        previewing,
+                        egui::Button::new(format!("{} Stop", icons::STOP.as_str())),
+                    )
+                    .clicked()
+                {
+                    stop = true;
+                }
+            });
+        });
+        property_row(ui, "Gain", |ui| {
+            ui.add(
+                egui::Slider::new(&mut source.gain_db, AUDIO_GAIN_DB_MIN..=AUDIO_GAIN_DB_MAX)
+                    .suffix(" dB"),
+            );
+        });
+        property_row(ui, "Pitch", |ui| {
+            ui.add(
+                egui::DragValue::new(&mut source.pitch)
+                    .range(0.25..=4.0)
+                    .speed(0.01),
+            );
+        });
+        property_row(ui, "Mode", |ui| {
+            ui.horizontal_wrapped(|ui| {
+                ui.checkbox(&mut source.autoplay, "Autoplay");
+                ui.checkbox(&mut source.looping, "Loop");
+            });
+        });
+        property_row(ui, "Spatial blend", |ui| {
+            ui.add(egui::Slider::new(&mut source.spatial_blend, 0.0..=1.0));
+        });
+        property_row(ui, "Min distance", |ui| {
+            ui.add(
+                egui::DragValue::new(&mut source.attenuation.min_distance)
+                    .range(0.01..=10_000.0)
+                    .speed(0.1)
+                    .suffix(" m"),
+            );
+        });
+        property_row(ui, "Max distance", |ui| {
+            ui.add(
+                egui::DragValue::new(&mut source.attenuation.max_distance)
+                    .range(0.02..=100_000.0)
+                    .speed(0.25)
+                    .suffix(" m"),
+            );
+        });
+        property_row(ui, "Rolloff", |ui| {
+            ui.horizontal_wrapped(|ui| {
+                egui::ComboBox::from_id_salt(("audio_rolloff", entity))
+                    .selected_text(format!("{:?}", source.attenuation.rolloff))
+                    .show_ui(ui, |ui| {
+                        for (rolloff, label) in [
+                            (AudioRolloff::Linear, "Linear"),
+                            (AudioRolloff::Inverse, "Inverse"),
+                            (AudioRolloff::Exponential, "Exponential"),
+                        ] {
+                            ui.selectable_value(&mut source.attenuation.rolloff, rolloff, label);
+                        }
+                    });
+                ui.add(
+                    egui::DragValue::new(&mut source.attenuation.rolloff_factor)
+                        .range(0.01..=8.0)
+                        .speed(0.05),
+                );
+            });
+        });
+        property_row(ui, "Bus", |ui| {
+            egui::ComboBox::from_id_salt(("audio_bus", entity))
+                .selected_text(
+                    buses
+                        .iter()
+                        .find(|bus| bus.id == source.bus)
+                        .map(|bus| bus.label.as_str())
+                        .unwrap_or(source.bus.as_str()),
+                )
+                .show_ui(ui, |ui| {
+                    for bus in &buses {
+                        ui.selectable_value(&mut source.bus, bus.id.clone(), &bus.label);
+                    }
+                });
+        });
+        ui.small(
+            egui::RichText::new(&diagnostics.message)
+                .color(TEXT_DIM)
+                .italics(),
+        );
+    });
+
+    if clear_clip {
+        source.clip = None;
+    }
+    if let Some(asset) = pending_clip {
+        match audio_clip_ref_for_asset(world, &asset) {
+            Ok(clip) => {
+                source.clip = Some(clip);
+                world.resource_mut::<EditorAssets>().clear_drag();
+            }
+            Err(error) => {
+                world.resource_mut::<crate::scene_io::SceneIo>().status =
+                    format!("Audio clip assignment failed: {error}");
+            }
+        }
+    }
+    source.attenuation.max_distance = source
+        .attenuation
+        .max_distance
+        .max(source.attenuation.min_distance + 0.01);
+    if source != original {
+        set_audio_source_with_history(world, entity, source);
+    }
+    if stop {
+        stop_audio_preview(world);
+    } else if audition {
+        if let Err(error) = audition_audio_source(world, entity) {
+            world.resource_mut::<crate::scene_io::SceneIo>().status =
+                format!("Audio audition failed: {error}");
+        }
+    }
+    apply_component_card_response(world, entity, card_response);
+}
+
+pub fn audio_listener_inspector_ui(world: &mut World, ui: &mut egui::Ui, entity: Entity) {
+    let Some(mut listener) = world.get::<AudioListenerDesc>(entity).copied() else {
+        return;
+    };
+    let original = listener;
+    let card = component_card_context(
+        world,
+        entity,
+        ComponentCardOptions::removable(
+            COMPONENT_AUDIO_LISTENER_DESC,
+            "Audio Listener",
+            icons::HEADPHONES,
+        ),
+    );
+    let card_response = component_card(ui, &card, |ui| {
+        property_row(ui, "Enabled", |ui| {
+            ui.checkbox(&mut listener.enabled, "Receive spatial audio");
+        });
+        property_row(ui, "Priority", |ui| {
+            ui.add(egui::DragValue::new(&mut listener.priority).speed(1));
+        });
+        property_row(ui, "Ear gap", |ui| {
+            ui.add(
+                egui::DragValue::new(&mut listener.ear_gap)
+                    .range(0.01..=2.0)
+                    .speed(0.01)
+                    .suffix(" m"),
+            );
+        });
+        ui.small(
+            egui::RichText::new("Highest priority enabled listener wins; actor ID breaks ties.")
+                .color(TEXT_DIM),
+        );
+    });
+    if listener != original {
+        set_audio_listener_with_history(world, entity, listener);
+    }
+    apply_component_card_response(world, entity, card_response);
+}
diff --git a/crates/editor/src/ui/build.rs b/crates/editor/src/ui/build.rs
new file mode 100644
index 0000000..8b94dcd
--- /dev/null
+++ b/crates/editor/src/ui/build.rs
@@ -0,0 +1,619 @@
+//! Non-blocking build/package jobs backed by the headless package command.
+
+use std::collections::VecDeque;
+use std::io::{BufRead, BufReader};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use bevy::prelude::*;
+use bevy_egui::egui;
+use egui_phosphor_icons::icons;
+
+use crate::project_io::ProjectWorkspace;
+use crate::scene_io::SceneIo;
+
+const MAX_LOG_LINES: usize = 1_500;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum BuildResult {
+    Succeeded(PathBuf),
+    Failed(String),
+    Cancelled,
+}
+
+#[derive(Debug)]
+struct BuildJob {
+    log: Arc<Mutex<VecDeque<String>>>,
+    result: Arc<Mutex<Option<BuildResult>>>,
+    cancel: Arc<AtomicBool>,
+    run_after: bool,
+    worker: Option<std::thread::JoinHandle<()>>,
+}
+
+impl Drop for BuildJob {
+    fn drop(&mut self) {
+        self.cancel.store(true, Ordering::Release);
+        if let Some(worker) = self.worker.take() {
+            let _ = worker.join();
+        }
+    }
+}
+
+#[derive(Resource, Debug)]
+pub struct BuildPanel {
+    profiles: Vec<String>,
+    selected_profile: String,
+    job: Option<BuildJob>,
+    last_result: Option<BuildResult>,
+    last_output: Option<PathBuf>,
+    last_log: Vec<String>,
+}
+
+impl Default for BuildPanel {
+    fn default() -> Self {
+        Self {
+            profiles: Vec::new(),
+            selected_profile: "development".into(),
+            job: None,
+            last_result: None,
+            last_output: None,
+            last_log: Vec::new(),
+        }
+    }
+}
+
+impl BuildPanel {
+    pub fn is_running(&self) -> bool {
+        self.job.is_some()
+    }
+
+    pub fn has_output(&self) -> bool {
+        self.last_output.is_some()
+    }
+}
+
+impl Drop for BuildPanel {
+    fn drop(&mut self) {
+        if let Some(job) = &self.job {
+            job.cancel.store(true, Ordering::Release);
+        }
+    }
+}
+
+pub fn request_build(world: &mut World, run_after: bool) {
+    refresh_profiles(world);
+    if world.resource::<BuildPanel>().is_running() {
+        world
+            .resource_mut::<SceneIo>()
+            .set_status("A package build is already running");
+        return;
+    }
+    if world.resource::<SceneIo>().has_unsaved_tabs() {
+        world
+            .resource_mut::<SceneIo>()
+            .set_status("Save all modified scene tabs before building a package");
+        return;
+    }
+    let engine_root = engine_workspace_root();
+    let root = PathBuf::from(&world.resource::<ProjectWorkspace>().root);
+    let profile = world.resource::<BuildPanel>().selected_profile.clone();
+    let mut panel = world.resource_mut::<BuildPanel>();
+    panel.last_result = None;
+    panel.last_log.clear();
+    panel.job = Some(spawn_build_job(
+        engine_root,
+        root,
+        profile.clone(),
+        run_after,
+    ));
+    world
+        .resource_mut::<SceneIo>()
+        .set_status(format!("Building {profile} package..."));
+}
+
+pub fn cancel_build(world: &mut World) {
+    if let Some(job) = world.resource::<BuildPanel>().job.as_ref() {
+        job.cancel.store(true, Ordering::Release);
+        world
+            .resource_mut::<SceneIo>()
+            .set_status("Cancelling package build...");
+    }
+}
+
+pub fn reveal_last_output(world: &mut World) {
+    let output = world.resource::<BuildPanel>().last_output.clone();
+    let status = match output {
+        Some(path) if path.is_dir() => match Command::new("xdg-open").arg(&path).spawn() {
+            Ok(child) => {
+                reap_child(child);
+                format!("Revealed {}", path.display())
+            }
+            Err(error) => format!("Could not reveal {}: {error}", path.display()),
+        },
+        _ => "No completed package output is available".into(),
+    };
+    world.resource_mut::<SceneIo>().set_status(status);
+}
+
+pub fn tick_build_job(world: &mut World) {
+    let completed = world.resource::<BuildPanel>().job.as_ref().and_then(|job| {
+        job.result
+            .lock()
+            .ok()?
+            .clone()
+            .map(|result| (result, job.run_after))
+    });
+    let Some((result, run_after)) = completed else {
+        return;
+    };
+    let status = match &result {
+        BuildResult::Succeeded(path) => {
+            world.resource_mut::<BuildPanel>().last_output = Some(path.clone());
+            if run_after {
+                launch_package(path)
+                    .map(|_| format!("Package built and launched from {}", path.display()))
+                    .unwrap_or_else(|error| error)
+            } else {
+                format!("Package ready at {}", path.display())
+            }
+        }
+        BuildResult::Failed(error) => format!("Package build failed: {error}"),
+        BuildResult::Cancelled => "Package build cancelled".into(),
+    };
+    let completed_log = world
+        .resource::<BuildPanel>()
+        .job
+        .as_ref()
+        .and_then(|job| {
+            job.log
+                .lock()
+                .ok()
+                .map(|log| log.iter().cloned().collect::<Vec<_>>())
+        })
+        .unwrap_or_default();
+    let mut panel = world.resource_mut::<BuildPanel>();
+    panel.last_result = Some(result);
+    panel.last_log = completed_log;
+    panel.job = None;
+    world.resource_mut::<SceneIo>().set_status(status);
+}
+
+pub fn build_ui(world: &mut World, ui: &mut egui::Ui) {
+    if world.resource::<BuildPanel>().profiles.is_empty() {
+        refresh_profiles(world);
+    }
+    let running = world.resource::<BuildPanel>().is_running();
+    let profiles = world.resource::<BuildPanel>().profiles.clone();
+    let mut selected = world.resource::<BuildPanel>().selected_profile.clone();
+    ui.horizontal(|ui| {
+        ui.label("Profile");
+        egui::ComboBox::from_id_salt("build_profile")
+            .selected_text(&selected)
+            .show_ui(ui, |ui| {
+                for profile in &profiles {
+                    ui.selectable_value(&mut selected, profile.clone(), profile);
+                }
+            });
+        if ui
+            .add_enabled(
+                !running,
+                egui::Button::new(format!("{} Build", icons::HAMMER.as_str())),
+            )
+            .clicked()
+        {
+            world.resource_mut::<BuildPanel>().selected_profile = selected.clone();
+            request_build(world, false);
+        }
+        if ui
+            .add_enabled(
+                !running,
+                egui::Button::new(format!("{} Build and Run", icons::PLAY.as_str())),
+            )
+            .clicked()
+        {
+            world.resource_mut::<BuildPanel>().selected_profile = selected.clone();
+            request_build(world, true);
+        }
+        if ui
+            .add_enabled(
+                running,
+                egui::Button::new(format!("{} Cancel", icons::X.as_str())),
+            )
+            .clicked()
+        {
+            cancel_build(world);
+        }
+        let can_reveal = world.resource::<BuildPanel>().last_output.is_some();
+        if ui
+            .add_enabled(
+                can_reveal,
+                egui::Button::new(format!("{} Reveal Output", icons::FOLDER_OPEN.as_str())),
+            )
+            .clicked()
+        {
+            reveal_last_output(world);
+        }
+    });
+    world.resource_mut::<BuildPanel>().selected_profile = selected;
+    ui.separator();
+    if running {
+        ui.horizontal(|ui| {
+            ui.spinner();
+            ui.label("Compiler and packager are running in the background");
+        });
+    } else if let Some(result) = world.resource::<BuildPanel>().last_result.clone() {
+        let (label, color) = match result {
+            BuildResult::Succeeded(path) => (
+                format!("Ready: {}", path.display()),
+                egui::Color32::from_rgb(125, 210, 145),
+            ),
+            BuildResult::Failed(error) => (
+                format!("Failed: {error}"),
+                egui::Color32::from_rgb(255, 137, 129),
+            ),
+            BuildResult::Cancelled => ("Cancelled".into(), egui::Color32::from_rgb(255, 190, 110)),
+        };
+        ui.colored_label(color, label);
+    } else {
+        ui.label("No package build has run in this session");
+    }
+    let lines = {
+        let panel = world.resource::<BuildPanel>();
+        panel
+            .job
+            .as_ref()
+            .and_then(|job| {
+                job.log
+                    .lock()
+                    .ok()
+                    .map(|log| log.iter().cloned().collect::<Vec<_>>())
+            })
+            .unwrap_or_else(|| panel.last_log.clone())
+    };
+    egui::ScrollArea::vertical()
+        .id_salt("build_output_log")
+        .stick_to_bottom(true)
+        .show(ui, |ui| {
+            for line in lines {
+                ui.monospace(line);
+            }
+        });
+}
+
+fn refresh_profiles(world: &mut World) {
+    let root = PathBuf::from(&world.resource::<ProjectWorkspace>().root);
+    let mut profiles = fs_profiles(&root.join("assets/build_profiles"));
+    if profiles.is_empty() {
+        profiles.push("development".into());
+    }
+    let mut panel = world.resource_mut::<BuildPanel>();
+    if !profiles.contains(&panel.selected_profile) {
+        panel.selected_profile = profiles[0].clone();
+    }
+    panel.profiles = profiles;
+}
+
+fn fs_profiles(root: &Path) -> Vec<String> {
+    let mut profiles = std::fs::read_dir(root)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .filter_map(|entry| {
+            let path = entry.path();
+            (path.extension().and_then(|extension| extension.to_str()) == Some("ron"))
+                .then(|| path.file_stem()?.to_str().map(str::to_string))?
+        })
+        .collect::<Vec<_>>();
+    profiles.sort();
+    profiles
+}
+
+fn spawn_build_job(
+    engine_root: PathBuf,
+    project_root: PathBuf,
+    profile: String,
+    run_after: bool,
+) -> BuildJob {
+    let log = Arc::new(Mutex::new(VecDeque::new()));
+    let result = Arc::new(Mutex::new(None));
+    let cancel = Arc::new(AtomicBool::new(false));
+    let thread_log = Arc::clone(&log);
+    let thread_result = Arc::clone(&result);
+    let thread_cancel = Arc::clone(&cancel);
+    let worker = std::thread::spawn(move || {
+        let mut command = Command::new("cargo");
+        command
+            .current_dir(&engine_root)
+            .args([
+                "package-project",
+                "--project",
+                &project_root.to_string_lossy(),
+                "--profile",
+                &profile,
+            ])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        #[cfg(unix)]
+        {
+            use std::os::unix::process::CommandExt;
+            command.process_group(0);
+        }
+        let mut child = match command.spawn() {
+            Ok(child) => child,
+            Err(error) => {
+                set_result(
+                    &thread_result,
+                    BuildResult::Failed(format!("could not start Cargo: {error}")),
+                );
+                return;
+            }
+        };
+        let output_path = Arc::new(Mutex::new(None));
+        let stdout_thread = child.stdout.take().map(|stdout| {
+            stream_output(
+                stdout,
+                Arc::clone(&thread_log),
+                Some(Arc::clone(&output_path)),
+            )
+        });
+        let stderr_thread = child
+            .stderr
+            .take()
+            .map(|stderr| stream_output(stderr, Arc::clone(&thread_log), None));
+        let mut poll_error = None;
+        let status = loop {
+            if thread_cancel.load(Ordering::Acquire) {
+                terminate_process_tree(&mut child);
+                let _ = child.wait();
+                break None;
+            }
+            match child.try_wait() {
+                Ok(Some(status)) => break Some(status),
+                Ok(None) => std::thread::sleep(Duration::from_millis(100)),
+                Err(error) => {
+                    terminate_process_tree(&mut child);
+                    let _ = child.wait();
+                    poll_error = Some(format!("could not poll build process: {error}"));
+                    break None;
+                }
+            }
+        };
+        if let Some(thread) = stdout_thread {
+            let _ = thread.join();
+        }
+        if let Some(thread) = stderr_thread {
+            let _ = thread.join();
+        }
+        let final_result = match (poll_error, status) {
+            (Some(error), _) => BuildResult::Failed(error),
+            (None, None) => BuildResult::Cancelled,
+            (None, Some(status)) if !status.success() => {
+                BuildResult::Failed(format!("packager exited with {status}"))
+            }
+            (None, Some(_)) => output_path
+                .lock()
+                .ok()
+                .and_then(|path| path.clone())
+                .map(BuildResult::Succeeded)
+                .unwrap_or_else(|| {
+                    BuildResult::Failed("packager did not report an output directory".into())
+                }),
+        };
+        set_result(&thread_result, final_result);
+    });
+    BuildJob {
+        log,
+        result,
+        cancel,
+        run_after,
+        worker: Some(worker),
+    }
+}
+
+fn engine_workspace_root() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .and_then(Path::parent)
+        .expect("editor crate must live under <workspace>/crates/editor")
+        .to_path_buf()
+}
+
+fn terminate_process_tree(child: &mut std::process::Child) {
+    #[cfg(unix)]
+    {
+        let process_group = format!("-{}", child.id());
+        let _ = Command::new("kill")
+            .args(["-TERM", "--", &process_group])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+        std::thread::sleep(Duration::from_millis(150));
+        let _ = Command::new("kill")
+            .args(["-KILL", "--", &process_group])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+    }
+    #[cfg(windows)]
+    {
+        let _ = Command::new("taskkill")
+            .args(["/PID", &child.id().to_string(), "/T", "/F"])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+    }
+    let _ = child.kill();
+}
+
+fn stream_output(
+    stream: impl std::io::Read + Send + 'static,
+    log: Arc<Mutex<VecDeque<String>>>,
+    output_path: Option<Arc<Mutex<Option<PathBuf>>>>,
+) -> std::thread::JoinHandle<()> {
+    std::thread::spawn(move || {
+        for line in BufReader::new(stream).lines().map_while(Result::ok) {
+            if let Some(path) = line.strip_prefix("package-project: ready at ") {
+                if let Some(output_path) = &output_path {
+                    if let Ok(mut output_path) = output_path.lock() {
+                        *output_path = Some(PathBuf::from(path));
+                    }
+                }
+            }
+            if let Ok(mut log) = log.lock() {
+                log.push_back(line);
+                while log.len() > MAX_LOG_LINES {
+                    log.pop_front();
+                }
+            }
+        }
+    })
+}
+
+fn set_result(result: &Arc<Mutex<Option<BuildResult>>>, value: BuildResult) {
+    if let Ok(mut result) = result.lock() {
+        *result = Some(value);
+    }
+}
+
+fn launch_package(output: &Path) -> Result<(), String> {
+    let metadata_path = output.join("build-metadata.json");
+    let metadata = std::fs::read_to_string(&metadata_path)
+        .map_err(|error| format!("Could not read {}: {error}", metadata_path.display()))?;
+    let metadata: serde_json::Value = serde_json::from_str(&metadata)
+        .map_err(|error| format!("Invalid {}: {error}", metadata_path.display()))?;
+    let target = metadata
+        .get("target")
+        .and_then(serde_json::Value::as_str)
+        .ok_or_else(|| format!("Package target is missing from {}", metadata_path.display()))?;
+    validate_launch_target(target, std::env::consts::ARCH, std::env::consts::OS)?;
+
+    let native_name = if cfg!(windows) {
+        "blacksite.exe"
+    } else {
+        "blacksite"
+    };
+    let foreign_name = if cfg!(windows) {
+        "blacksite"
+    } else {
+        "blacksite.exe"
+    };
+    let executable = output.join(native_name);
+    if !executable.is_file() {
+        let foreign = output.join(foreign_name);
+        if foreign.is_file() {
+            return Err(format!(
+                "Package {} targets a different operating system and cannot run on this host",
+                foreign.display()
+            ));
+        }
+        return Err(format!(
+            "Package executable is missing at {}",
+            executable.display()
+        ));
+    }
+    let child = Command::new(&executable)
+        .current_dir(output)
+        .spawn()
+        .map_err(|error| format!("Could not launch {}: {error}", executable.display()))?;
+    reap_child(child);
+    Ok(())
+}
+
+fn validate_launch_target(target: &str, host_arch: &str, host_os: &str) -> Result<(), String> {
+    let segments = target.split('-').collect::<Vec<_>>();
+    let target_os = if segments.contains(&"windows") {
+        "windows"
+    } else if segments.contains(&"linux") && !segments.contains(&"android") {
+        "linux"
+    } else {
+        return Err(format!(
+            "Package target `{target}` is not a runnable desktop target"
+        ));
+    };
+    let target_arch = segments.first().copied().unwrap_or_default();
+    let target_arch = normalize_architecture(target_arch);
+    let host_arch = normalize_architecture(host_arch);
+    if target_os != host_os || target_arch != host_arch {
+        return Err(format!(
+            "Package targets {target_arch}-{target_os}, but this host is {host_arch}-{host_os}"
+        ));
+    }
+    Ok(())
+}
+
+fn normalize_architecture(architecture: &str) -> &str {
+    match architecture {
+        "i386" | "i486" | "i586" | "i686" | "x86" => "x86",
+        architecture if architecture.starts_with("armv") => "arm",
+        architecture => architecture,
+    }
+}
+
+fn reap_child(mut child: std::process::Child) {
+    std::thread::spawn(move || {
+        let _ = child.wait();
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn profile_scan_is_sorted_and_uses_file_stems() {
+        let root =
+            std::env::temp_dir().join(format!("blacksite-build-profiles-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(&root).unwrap();
+        std::fs::write(root.join("release.ron"), "()").unwrap();
+        std::fs::write(root.join("development.ron"), "()").unwrap();
+        std::fs::write(root.join("ignore.txt"), "").unwrap();
+        assert_eq!(fs_profiles(&root), vec!["development", "release"]);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn engine_workspace_contains_the_game_package() {
+        let root = engine_workspace_root();
+        assert!(root.join("Cargo.toml").is_file());
+        assert!(root.join("crates/game/Cargo.toml").is_file());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn cancellation_terminates_the_compiler_process_group() {
+        use std::os::unix::process::CommandExt;
+        use std::time::Instant;
+
+        let mut command = Command::new("sh");
+        command
+            .args(["-c", "(trap '' TERM; sleep 30) & wait"])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .process_group(0);
+        let mut child = command.spawn().unwrap();
+        let started = Instant::now();
+        terminate_process_tree(&mut child);
+        let status = child.wait().unwrap();
+        assert!(!status.success());
+        assert!(started.elapsed() < Duration::from_secs(3));
+    }
+
+    #[test]
+    fn package_launch_rejects_same_os_cross_architecture_targets() {
+        assert!(validate_launch_target("x86_64-unknown-linux-gnu", "x86_64", "linux").is_ok());
+        assert!(
+            validate_launch_target("aarch64-unknown-linux-gnu", "x86_64", "linux")
+                .unwrap_err()
+                .contains("aarch64-linux")
+        );
+        assert!(
+            validate_launch_target("x86_64-pc-windows-msvc", "x86_64", "linux")
+                .unwrap_err()
+                .contains("windows")
+        );
+    }
+}
diff --git a/crates/editor/src/ui/component_registry.rs b/crates/editor/src/ui/component_registry.rs
index 3d139fd..51087a1 100644
--- a/crates/editor/src/ui/component_registry.rs
+++ b/crates/editor/src/ui/component_registry.rs
@@ -7,6 +7,8 @@ use egui_phosphor_icons::icons;
 pub enum EditorComponentCategory {
     Authoring,
     Rendering,
+    Animation,
+    Audio,
     Physics,
     Gameplay,
     Volumes,
@@ -136,6 +138,54 @@ impl Default for EditorComponentRegistry {
                     conflicts_with: &[],
                     hydration_effect: "Hydrates into runtime Bevy light components.",
                 },
+                EditorComponentDescriptor {
+                    type_name: "shared::animation::AnimationControllerDesc",
+                    display_name: "Animation Controller",
+                    category: EditorComponentCategory::Animation,
+                    addable: true,
+                    removable: true,
+                    reorderable: true,
+                    hidden: false,
+                    icon: icons::FILM_SLATE.as_str(),
+                    description: "Authors named animation states for an imported model rig.",
+                    search_terms: &["animation", "controller", "state", "clip", "skeleton", "rig"],
+                    recommended: &[],
+                    conflicts_with: &[],
+                    hydration_effect:
+                        "Hydrates into a Bevy animation graph and player bound to the imported model.",
+                },
+                EditorComponentDescriptor {
+                    type_name: "shared::components::AudioSourceDesc",
+                    display_name: "Audio Source",
+                    category: EditorComponentCategory::Audio,
+                    addable: true,
+                    removable: true,
+                    reorderable: true,
+                    hidden: false,
+                    icon: icons::SPEAKER_HIGH.as_str(),
+                    description: "Plays a routed 2D or spatial audio clip from this actor.",
+                    search_terms: &["audio", "sound", "clip", "speaker", "spatial"],
+                    recommended: &[],
+                    conflicts_with: &["shared::components::AudioListenerDesc"],
+                    hydration_effect:
+                        "Hydrates into runtime Bevy audio voices with bus and attenuation control.",
+                },
+                EditorComponentDescriptor {
+                    type_name: "shared::components::AudioListenerDesc",
+                    display_name: "Audio Listener",
+                    category: EditorComponentCategory::Audio,
+                    addable: true,
+                    removable: true,
+                    reorderable: true,
+                    hidden: false,
+                    icon: icons::HEADPHONES.as_str(),
+                    description: "Receives spatial audio at this actor transform.",
+                    search_terms: &["audio", "sound", "listener", "ears", "spatial"],
+                    recommended: &[],
+                    conflicts_with: &["shared::components::AudioSourceDesc"],
+                    hydration_effect:
+                        "The highest-priority enabled listener becomes the runtime listener.",
+                },
                 EditorComponentDescriptor {
                     type_name: "shared::components::Primitive",
                     display_name: "Primitive",
diff --git a/crates/editor/src/ui/diagnostics.rs b/crates/editor/src/ui/diagnostics.rs
index d0cd44a..7236ae7 100644
--- a/crates/editor/src/ui/diagnostics.rs
+++ b/crates/editor/src/ui/diagnostics.rs
@@ -8,16 +8,19 @@ use shared::{
 };
 
 use crate::assets::EditorAssets;
+use crate::diagnostics_bundle::export_diagnostic_bundle;
 use crate::history::set_brush_with_history;
 use crate::history::EditorHistory;
 use crate::project_io::ProjectWorkspace;
-use crate::scene_io::SceneIo;
+use crate::scene_io::{SceneIo, SceneIoEventSeverity};
 use crate::selection::SelectedEntity;
 use crate::ui::UiState;
 
 #[derive(Resource, Default)]
 pub struct DiagnosticsPanel {
     pub open: bool,
+    pub bundle_status: Option<String>,
+    pub project_validation: Option<scene::ProjectValidationReport>,
 }
 
 #[derive(Resource, Default)]
@@ -26,10 +29,18 @@ pub struct BrushDiagnosticsPanel {
 }
 
 pub fn diagnostics_ui(world: &mut World, ui: &mut egui::Ui) {
-    let scene_io = world.resource::<SceneIo>();
-    let dirty = if scene_io.dirty { " (dirty)" } else { "" };
-    ui.label(format!("Scene: {}{dirty}", scene_io.active_path_label()));
-    ui.label(format!("Status: {}", scene_io.status));
+    let (scene_label, dirty, status, scene_events) = {
+        let scene_io = world.resource::<SceneIo>();
+        (
+            scene_io.active_path_label(),
+            scene_io.dirty,
+            scene_io.status.clone(),
+            scene_io.events.iter().rev().cloned().collect::<Vec<_>>(),
+        )
+    };
+    let dirty = if dirty { " (dirty)" } else { "" };
+    ui.label(format!("Scene: {scene_label}{dirty}"));
+    ui.label(format!("Status: {status}"));
     ui.label(format!(
         "History: {}",
         world.resource::<EditorHistory>().status
@@ -58,6 +69,125 @@ pub fn diagnostics_ui(world: &mut World, ui: &mut egui::Ui) {
     let count = level_query.iter(world).count();
     ui.label(format!("Level objects: {count}"));
 
+    ui.separator();
+    ui.horizontal(|ui| {
+        ui.strong("Project validation");
+        if ui.button("Validate Project").clicked() {
+            let root = world.resource::<ProjectWorkspace>().root.clone();
+            let report = scene::validate_project(std::path::Path::new(&root));
+            let summary = format!(
+                "Project validation: {} dependencies, {} findings, {} blocking errors",
+                report.dependencies.len(),
+                report.findings.len(),
+                report.blocking_error_count()
+            );
+            world.resource_mut::<SceneIo>().set_status(summary);
+            world.resource_mut::<DiagnosticsPanel>().project_validation = Some(report);
+        }
+    });
+    if let Some(report) = world
+        .resource::<DiagnosticsPanel>()
+        .project_validation
+        .as_ref()
+        .cloned()
+    {
+        let color = if report.is_release_ready() {
+            egui::Color32::from_rgb(125, 210, 145)
+        } else {
+            egui::Color32::from_rgb(255, 137, 129)
+        };
+        ui.colored_label(
+            color,
+            format!(
+                "{} dependencies, {} blocking errors",
+                report.dependencies.len(),
+                report.blocking_error_count()
+            ),
+        );
+        for finding in report.findings.iter().take(12) {
+            let actor = finding
+                .owner_actor_id
+                .as_deref()
+                .map(|actor| format!(" / {actor}"))
+                .unwrap_or_default();
+            ui.horizontal_wrapped(|ui| {
+                ui.monospace(format!("{}{}", finding.source_path, actor));
+                ui.label(&finding.message);
+                if let Some(actor_id) = finding.owner_actor_id.as_deref() {
+                    if ui.small_button("Select").clicked() {
+                        let mut query = world.query::<(Entity, &shared::ActorId)>();
+                        if let Some(entity) = query
+                            .iter(world)
+                            .find_map(|(entity, id)| (id.0 == actor_id).then_some(entity))
+                        {
+                            world.resource_mut::<SelectedEntity>().0 = Some(entity);
+                            world
+                                .resource_mut::<UiState>()
+                                .selected_entities
+                                .select_replace(entity);
+                        }
+                    }
+                }
+            });
+        }
+        if report.findings.len() > 12 {
+            ui.small(format!(
+                "{} additional findings",
+                report.findings.len() - 12
+            ));
+        }
+    }
+
+    ui.separator();
+    ui.horizontal(|ui| {
+        ui.strong("Support bundle");
+        if ui.button("Export Diagnostic Bundle").clicked() {
+            let status = match export_diagnostic_bundle(world) {
+                Ok(path) => format!("Exported {}", path.display()),
+                Err(error) => format!("Export failed: {error}"),
+            };
+            world.resource_mut::<DiagnosticsPanel>().bundle_status = Some(status);
+        }
+    });
+    ui.small("Allowlisted metadata only; scene and asset contents, environment values, credentials, and modal state are excluded.");
+    if let Some(status) = world
+        .resource::<DiagnosticsPanel>()
+        .bundle_status
+        .as_deref()
+    {
+        ui.monospace(status);
+    }
+
+    ui.separator();
+    ui.horizontal(|ui| {
+        ui.strong("Scene I/O log");
+        if ui
+            .add_enabled(!scene_events.is_empty(), egui::Button::new("Clear"))
+            .clicked()
+        {
+            world.resource_mut::<SceneIo>().clear_events();
+        }
+    });
+    if scene_events.is_empty() {
+        ui.small("No scene I/O operations recorded this session.");
+    } else {
+        egui::ScrollArea::vertical()
+            .id_salt("scene_io_diagnostics_log")
+            .max_height(180.0)
+            .show(ui, |ui| {
+                for event in scene_events {
+                    let color = match event.severity {
+                        SceneIoEventSeverity::Info => ui.visuals().weak_text_color(),
+                        SceneIoEventSeverity::Error => egui::Color32::from_rgb(244, 110, 105),
+                    };
+                    ui.horizontal_wrapped(|ui| {
+                        ui.colored_label(color, format!("#{:02}", event.id));
+                        ui.colored_label(color, event.message);
+                    });
+                }
+            });
+    }
+
     ui.separator();
     ui.small("Native Bevy scenes are saved to assets/levels/*.scn.ron");
     ui.small("BRP is enabled on the editor for external tooling.");
diff --git a/crates/editor/src/ui/dock_tabs.rs b/crates/editor/src/ui/dock_tabs.rs
index 8fa92d0..f5134b6 100644
--- a/crates/editor/src/ui/dock_tabs.rs
+++ b/crates/editor/src/ui/dock_tabs.rs
@@ -36,7 +36,7 @@ impl PanelNodes {
             EditorTab::Viewport | EditorTab::GameView => self.main_view(),
             EditorTab::Hierarchy => self.hierarchy(),
             EditorTab::Inspector => self.inspector(),
-            EditorTab::AssetBrowser | EditorTab::Toolbar => self.bottom(),
+            EditorTab::AssetBrowser | EditorTab::Build | EditorTab::Toolbar => self.bottom(),
         }
     }
 
@@ -51,18 +51,21 @@ impl PanelNodes {
                 EditorTab::Viewport | EditorTab::GameView => nodes.main_view = path.node.0,
                 EditorTab::Hierarchy => nodes.hierarchy = path.node.0,
                 EditorTab::Inspector => nodes.inspector = path.node.0,
-                EditorTab::AssetBrowser | EditorTab::Toolbar => nodes.bottom = path.node.0,
+                EditorTab::AssetBrowser | EditorTab::Build | EditorTab::Toolbar => {
+                    nodes.bottom = path.node.0
+                }
             }
         }
         nodes
     }
 }
 
-pub const PANEL_TABS: [EditorTab; 4] = [
+pub const PANEL_TABS: [EditorTab; 5] = [
     EditorTab::Viewport,
     EditorTab::Hierarchy,
     EditorTab::Inspector,
     EditorTab::AssetBrowser,
+    EditorTab::Build,
 ];
 
 pub fn tab_label(tab: &EditorTab) -> &'static str {
@@ -71,6 +74,7 @@ pub fn tab_label(tab: &EditorTab) -> &'static str {
         EditorTab::Hierarchy => "Hierarchy",
         EditorTab::Inspector => "Inspector",
         EditorTab::AssetBrowser => "Asset Browser",
+        EditorTab::Build => "Build",
         EditorTab::Toolbar => "Toolbar (legacy)",
     }
 }
diff --git a/crates/editor/src/ui/helpers.rs b/crates/editor/src/ui/helpers.rs
index b87453b..3c7428e 100644
--- a/crates/editor/src/ui/helpers.rs
+++ b/crates/editor/src/ui/helpers.rs
@@ -11,7 +11,7 @@ use sim::Player;
 use crate::assets::{snapshot_for_asset, EditorAsset, EditorAssetKind};
 use crate::camera::EditorCamera;
 use crate::gizmos::{EditorGizmoMode, EditorGizmoSpace};
-use crate::history::{set_material_with_history, spawn_with_history, EditorEntitySnapshot};
+use crate::history::{set_material_group_with_history, spawn_with_history, EditorEntitySnapshot};
 use crate::play::default_player_spawn;
 use crate::scene_io::SceneIo;
 use crate::viewport::{recall_camera_bookmark, save_camera_bookmark, CameraBookmarks};
@@ -97,6 +97,9 @@ pub fn light_snapshot(name: &str, translation: Vec3) -> EditorEntitySnapshot {
         collider: None,
         physics: None,
         light: Some(LightDesc::default()),
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
@@ -145,6 +148,9 @@ pub fn ensure_player_spawn_for_edit(world: &mut World) -> Entity {
             collider: None,
             physics: None,
             light: None,
+            animation_controller: None,
+            audio_source: None,
+            audio_listener: None,
             player_spawn: true,
             model: None,
             prefab: None,
@@ -233,6 +239,9 @@ pub fn create_scene_sun_override_from_project_settings(world: &mut World) -> Ent
             collider: None,
             physics: None,
             light: Some(light),
+            animation_controller: None,
+            audio_source: None,
+            audio_listener: None,
             player_spawn: false,
             model: None,
             prefab: None,
@@ -256,6 +265,7 @@ pub fn asset_label(asset: &EditorAsset) -> String {
         EditorAssetKind::Model => "Model",
         EditorAssetKind::Texture => "Texture",
         EditorAssetKind::Material => "Material",
+        EditorAssetKind::AudioClip => "Audio Clip",
         EditorAssetKind::Level => "Level",
         EditorAssetKind::Prefab => "Prefab",
         EditorAssetKind::PostProcessVolume => "Post Process Volume",
@@ -270,26 +280,32 @@ pub fn apply_texture_to_selection(
     world: &mut World,
     asset: &EditorAsset,
     selected: &SelectedEntities,
-) {
-    let Some(path) = asset.path.clone() else {
-        return;
-    };
-    for entity in selected_level_entities(world, selected) {
-        let mut material = world
-            .get::<MaterialDesc>(entity)
-            .cloned()
-            .unwrap_or_default();
-        material.base_color_texture = Some(path.clone());
-        set_material_with_history(world, entity, material);
-    }
+) -> Result<(), String> {
+    let path = asset
+        .path
+        .clone()
+        .ok_or_else(|| format!("Texture has no source path: {}", asset.label))?;
+    let changes = selected_level_entities(world, selected)
+        .into_iter()
+        .map(|entity| {
+            let mut material = world
+                .get::<MaterialDesc>(entity)
+                .cloned()
+                .unwrap_or_default();
+            material.base_color_texture = Some(path.clone());
+            (entity, material)
+        })
+        .collect::<Vec<_>>();
+    set_material_group_with_history(world, changes);
+    Ok(())
 }
 
 pub fn apply_material_asset_to_selection(
     world: &mut World,
     asset: &EditorAsset,
     selected: &SelectedEntities,
-) {
-    crate::assets::materials::apply_material_asset_to_selection(world, asset, selected);
+) -> Result<(), String> {
+    crate::assets::materials::apply_material_asset_to_selection(world, asset, selected)
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/crates/editor/src/ui/hierarchy.rs b/crates/editor/src/ui/hierarchy.rs
index 1a8b9a9..840d228 100644
--- a/crates/editor/src/ui/hierarchy.rs
+++ b/crates/editor/src/ui/hierarchy.rs
@@ -5,7 +5,7 @@ use bevy_egui::egui;
 use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
 use egui::containers::scroll_area::ScrollSource;
 use egui_phosphor_icons::icons;
-use shared::EditorVisibility;
+use shared::{EditorVisibility, HydratedPrefabMember};
 
 use crate::history::{
     create_empty_child_with_history, delete_entities_with_history, duplicate_entities_with_history,
@@ -19,11 +19,17 @@ use crate::ui::helpers::{
 };
 use crate::ui::hierarchy_ops::{
     authored_children, editor_visibility, entity_hierarchy_path, entity_matches_filter,
-    hierarchy_label_for_entity, is_entity_locked, level_object_roots, sort_siblings,
-    would_create_cycle, HierarchyLabel,
+    hierarchy_drop_violation, hierarchy_label_for_entity, is_ancestor, is_entity_locked,
+    level_object_roots, mutable_authored_children, sort_siblings, HierarchyDropViolation,
+    HierarchyLabel,
 };
 use crate::ui::hierarchy_state::{HierarchyPanelState, HierarchySort};
-use crate::ui::theme::{panel_heading, TEXT, TEXT_DIM, TEXT_SELECTED};
+use crate::ui::selection_ops::is_linked_read_only;
+use crate::ui::theme::{
+    overlay_chip_frame, panel_heading, ACCENT, ERROR, PANEL_BG_DARK, SELECTION, SELECTION_BG_MUTED,
+    SELECTION_SECONDARY, TEXT, TEXT_DIM, TEXT_MUTED, TEXT_SELECTED,
+};
+use crate::ui::widgets::phosphor_icon;
 
 #[derive(Clone)]
 struct HierarchyDragPayload {
@@ -37,6 +43,12 @@ enum DropTarget {
     Before(Entity),
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum DropBlock {
+    Hierarchy(HierarchyDropViolation),
+    LockedTarget(Entity),
+}
+
 pub fn hierarchy_panel_ui(
     world: &mut World,
     ui: &mut egui::Ui,
@@ -121,7 +133,7 @@ pub fn hierarchy_panel_ui(
 
     if ui.input(|input| input.key_pressed(egui::Key::F2)) {
         if let Some(entity) = selected_entities.as_slice().first().copied() {
-            if is_level_object(world, entity) {
+            if is_level_object(world, entity) && !is_entity_locked(&locked, entity) {
                 *renaming_entity = Some(entity);
                 *rename_buffer = entity_name(world, entity);
             }
@@ -130,12 +142,10 @@ pub fn hierarchy_panel_ui(
 
     let filter_lower = filter.trim().to_lowercase();
     let mut drop_target = None;
-    let mut invalid_drop = false;
+    let mut drop_block = None;
 
-    let dragging = world
-        .resource::<HierarchyPanelState>()
-        .active_drag
-        .is_some();
+    let active_drag = world.resource::<HierarchyPanelState>().active_drag.clone();
+    let dragging = active_drag.is_some();
 
     egui::ScrollArea::vertical()
         .id_salt("hierarchy_tree")
@@ -148,7 +158,7 @@ pub fn hierarchy_panel_ui(
             ui.spacing_mut().item_spacing.y = 2.0;
 
             if dragging {
-                draw_root_drop_zone(ui, &mut drop_target);
+                draw_root_drop_zone(ui, active_drag.as_deref(), &mut drop_target);
             }
 
             let mut roots = level_object_roots(world);
@@ -171,12 +181,12 @@ pub fn hierarchy_panel_ui(
                     &filter_lower,
                     sort_mode,
                     show_generated,
-                    dragging,
+                    active_drag.as_deref(),
                     &expanded,
                     &locked,
                     &prefs_paths,
                     &mut drop_target,
-                    &mut invalid_drop,
+                    &mut drop_block,
                 );
             }
 
@@ -192,6 +202,8 @@ pub fn hierarchy_panel_ui(
             }
         });
 
+    draw_hierarchy_drag_preview(world, ui, active_drag.as_deref(), drop_target, drop_block);
+
     if ui.ctx().input(|input| input.pointer.any_released()) {
         if let Some(target) = drop_target {
             let drag_entities = world
@@ -200,7 +212,7 @@ pub fn hierarchy_panel_ui(
                 .take();
             if let Some(entities) = drag_entities {
                 let payload = HierarchyDragPayload { entities };
-                apply_drop(world, &payload, target, invalid_drop);
+                apply_drop(world, &payload, target, drop_block);
             }
         } else {
             world.resource_mut::<HierarchyPanelState>().active_drag = None;
@@ -220,14 +232,45 @@ fn sort_label(sort: HierarchySort) -> &'static str {
     }
 }
 
-fn draw_root_drop_zone(ui: &mut egui::Ui, drop_target: &mut Option<DropTarget>) {
+fn draw_root_drop_zone(
+    ui: &mut egui::Ui,
+    drag_entities: Option<&[Entity]>,
+    drop_target: &mut Option<DropTarget>,
+) {
     let (rect, response) =
-        ui.allocate_exact_size(egui::vec2(ui.available_width(), 2.0), egui::Sense::hover());
-    if let Some(hover) = response.dnd_hover_payload::<HierarchyDragPayload>() {
-        ui.painter()
-            .rect_filled(rect, 1.0, egui::Color32::from_rgb(80, 120, 200));
+        ui.allocate_exact_size(egui::vec2(ui.available_width(), 27.0), egui::Sense::hover());
+    let hovered = drag_entities.is_some()
+        && (response.contains_pointer()
+            || response
+                .dnd_hover_payload::<HierarchyDragPayload>()
+                .is_some());
+    ui.painter().rect(
+        rect,
+        2.0,
+        if hovered {
+            SELECTION_BG_MUTED
+        } else {
+            PANEL_BG_DARK
+        },
+        egui::Stroke::new(1.0, if hovered { SELECTION } else { TEXT_MUTED }),
+        egui::StrokeKind::Inside,
+    );
+    ui.painter().text(
+        rect.left_center() + egui::vec2(9.0, 0.0),
+        egui::Align2::LEFT_CENTER,
+        icons::TREE_STRUCTURE.as_str(),
+        egui::FontId::new(13.0, egui::FontFamily::Name("phosphor-regular".into())),
+        if hovered { SELECTION } else { TEXT_DIM },
+    );
+    ui.painter().text(
+        rect.left_center() + egui::vec2(29.0, 0.0),
+        egui::Align2::LEFT_CENTER,
+        "SCENE ROOT",
+        egui::FontId::new(11.0, egui::FontFamily::Proportional),
+        if hovered { TEXT_SELECTED } else { TEXT_DIM },
+    );
+    if hovered {
         *drop_target = Some(DropTarget::Root);
-        let _ = hover;
     }
 }
 
@@ -246,12 +289,12 @@ fn draw_authored_node(
     filter_lower: &str,
     sort_mode: HierarchySort,
     show_generated: bool,
-    drag_active: bool,
+    drag_entities: Option<&[Entity]>,
     expanded: &std::collections::HashSet<Entity>,
     locked: &std::collections::HashSet<Entity>,
     prefs_paths: &[String],
     drop_target: &mut Option<DropTarget>,
-    invalid_drop: &mut bool,
+    drop_block: &mut Option<DropBlock>,
 ) {
     let path = entity_hierarchy_path(world, entity);
     let mut is_expanded = expanded.contains(&entity) || prefs_paths.iter().any(|p| p == &path);
@@ -265,15 +308,18 @@ fn draw_authored_node(
                     .any(|child| is_hierarchy_generated_child(world, child))
             }));
 
-    draw_drop_before(
-        world,
-        ui,
-        entity,
-        depth,
-        drag_active,
-        drop_target,
-        invalid_drop,
-    );
+    if sort_mode == HierarchySort::Manual {
+        draw_drop_before(
+            world,
+            ui,
+            entity,
+            depth,
+            drag_entities,
+            locked,
+            drop_target,
+            drop_block,
+        );
+    }
 
     ui.horizontal(|ui| {
         ui.add_space(depth as f32 * 14.0);
@@ -318,21 +364,37 @@ fn draw_authored_node(
             ui.add_space(18.0);
         }
 
+        let linked_read_only = is_linked_read_only(world, entity);
+        let is_locked = is_entity_locked(locked, entity);
         let visible = editor_visibility(world, entity).visible;
         let eye_icon = if visible {
             icons::EYE.regular()
         } else {
             icons::EYE_SLASH.regular()
         };
-        if ui.small_button(eye_icon).clicked() {
-            set_editor_visibility_with_history(
-                world,
-                entity,
-                EditorVisibility { visible: !visible },
-            );
+        let prefab_member = world.get::<HydratedPrefabMember>(entity).is_some();
+        if ui
+            .add_enabled(
+                !is_locked && (!linked_read_only || prefab_member),
+                egui::Button::new(eye_icon),
+            )
+            .clicked()
+        {
+            if prefab_member {
+                crate::assets::prefab_overrides::set_prefab_component_override(
+                    world,
+                    entity,
+                    EditorVisibility { visible: !visible },
+                );
+            } else {
+                set_editor_visibility_with_history(
+                    world,
+                    entity,
+                    EditorVisibility { visible: !visible },
+                );
+            }
         }
 
-        let is_locked = is_entity_locked(locked, entity);
         let lock_icon = if is_locked {
             icons::LOCK.regular()
         } else {
@@ -351,15 +413,33 @@ fn draw_authored_node(
             let response = ui.text_edit_singleline(rename_buffer);
             let commit =
                 response.lost_focus() || ui.input(|input| input.key_pressed(egui::Key::Enter));
-            if commit {
+            if commit && !is_locked && !linked_read_only {
                 rename_entity_with_history(world, entity, rename_buffer.clone());
                 *renaming_entity = None;
             }
         } else {
             let selected = selected_entities.contains(entity);
+            let primary = selected_entities.as_slice().first().copied() == Some(entity);
             let label = hierarchy_label_for_entity(world, entity, HierarchyNodeKind::Authored);
             let color = if selected { TEXT_SELECTED } else { TEXT };
-            let response = ui.selectable_label(selected, hierarchy_label_text(label, color));
+            let response = ui.add_sized(
+                egui::vec2(ui.available_width().max(72.0), 24.0),
+                egui::Button::selectable(selected, hierarchy_label_text(label, color))
+                    .sense(egui::Sense::click_and_drag()),
+            );
+            if selected {
+                ui.painter().line_segment(
+                    [response.rect.left_top(), response.rect.left_bottom()],
+                    egui::Stroke::new(
+                        if primary { 3.0 } else { 2.0 },
+                        if primary {
+                            SELECTION
+                        } else {
+                            SELECTION_SECONDARY
+                        },
+                    ),
+                );
+            }
             if response.clicked() && !is_locked {
                 let additive = ui.input(|input| {
                     input.modifiers.shift || input.modifiers.command || input.modifiers.ctrl
@@ -371,38 +451,37 @@ fn draw_authored_node(
                 }
                 world.resource_mut::<SelectedEntity>().0 = Some(entity);
             }
-            if response.double_clicked() && is_level_object(world, entity) {
+            if response.double_clicked()
+                && is_level_object(world, entity)
+                && !is_locked
+                && !linked_read_only
+            {
                 *renaming_entity = Some(entity);
                 *rename_buffer = entity_name(world, entity);
             }
 
-            if response.drag_started() {
-                let drag_entities: Vec<Entity> = if selected_entities.contains(entity) {
-                    selected_entities
-                        .iter()
-                        .filter(|e| is_level_object(world, *e))
-                        .collect()
+            if response.drag_started() && !is_locked && (!linked_read_only || prefab_member) {
+                let candidates: Vec<Entity> = if selected_entities.contains(entity) {
+                    selected_entities.iter().collect()
                 } else {
                     vec![entity]
                 };
+                let drag_entities = draggable_selection(world, &candidates, locked);
                 response.dnd_set_drag_payload(HierarchyDragPayload {
                     entities: drag_entities.clone(),
                 });
                 world.resource_mut::<HierarchyPanelState>().active_drag = Some(drag_entities);
             }
 
-            if let Some(hover) = response.dnd_hover_payload::<HierarchyDragPayload>() {
-                let invalid = would_create_cycle(world, &hover.entities, Some(entity));
-                *invalid_drop = invalid;
+            let hover_payload = response.dnd_hover_payload::<HierarchyDragPayload>();
+            let hovered_entities = hover_payload
+                .as_deref()
+                .map(|payload| payload.entities.as_slice())
+                .or_else(|| drag_entities.filter(|_| response.contains_pointer()));
+            if let Some(entities) = hovered_entities {
+                *drop_block = drop_block_for_target(world, locked, entities, Some(entity), entity);
                 *drop_target = Some(DropTarget::On(entity));
-                if invalid {
-                    ui.painter().rect_stroke(
-                        response.rect,
-                        2.0,
-                        egui::Stroke::new(2.0, egui::Color32::RED),
-                        egui::StrokeKind::Outside,
-                    );
-                }
+                draw_attach_target_feedback(ui, response.rect, drop_block.is_some());
             }
 
             response.context_menu(|ui| {
@@ -413,6 +492,7 @@ fn draw_authored_node(
                     selected_entities,
                     renaming_entity,
                     rename_buffer,
+                    locked,
                 )
             });
         }
@@ -437,12 +517,12 @@ fn draw_authored_node(
                 filter_lower,
                 sort_mode,
                 show_generated,
-                drag_active,
+                drag_entities,
                 expanded,
                 locked,
                 prefs_paths,
                 drop_target,
-                invalid_drop,
+                drop_block,
             );
         }
     }
@@ -458,43 +538,94 @@ fn draw_authored_node(
     }
 }
 
+#[expect(
+    clippy::too_many_arguments,
+    reason = "immediate-mode drop feedback threads the current drag, lock, and target state"
+)]
 fn draw_drop_before(
     world: &World,
     ui: &mut egui::Ui,
     entity: Entity,
     depth: usize,
-    drag_active: bool,
+    drag_entities: Option<&[Entity]>,
+    locked: &std::collections::HashSet<Entity>,
     drop_target: &mut Option<DropTarget>,
-    invalid_drop: &mut bool,
+    drop_block: &mut Option<DropBlock>,
 ) {
-    if !drag_active {
+    let Some(drag_entities) = drag_entities else {
         return;
-    }
+    };
 
     ui.horizontal(|ui| {
         ui.add_space(depth as f32 * 14.0 + 18.0);
         let (rect, response) =
-            ui.allocate_exact_size(egui::vec2(ui.available_width(), 2.0), egui::Sense::hover());
-        if let Some(hover) = response.dnd_hover_payload::<HierarchyDragPayload>() {
-            *invalid_drop = would_create_cycle(
-                world,
-                &hover.entities,
-                world
-                    .get::<ChildOf>(entity)
-                    .map(|child_of| child_of.parent()),
-            );
-            *drop_target = Some(DropTarget::Before(entity));
-            let color = if *invalid_drop {
-                egui::Color32::RED
+            ui.allocate_exact_size(egui::vec2(ui.available_width(), 7.0), egui::Sense::hover());
+        let hovered = response.contains_pointer()
+            || response
+                .dnd_hover_payload::<HierarchyDragPayload>()
+                .is_some();
+        if hovered {
+            let parent = world
+                .get::<ChildOf>(entity)
+                .map(|child_of| child_of.parent());
+            *drop_block = if world.get::<HydratedPrefabMember>(entity).is_some()
+                || drag_entities
+                    .iter()
+                    .any(|dragged| world.get::<HydratedPrefabMember>(*dragged).is_some())
+            {
+                let root =
+                    crate::assets::prefab_overrides::prefab_member_override_target(world, entity)
+                        .map(|(root, _)| root)
+                        .unwrap_or(entity);
+                Some(DropBlock::Hierarchy(
+                    HierarchyDropViolation::PrefabBoundary { root },
+                ))
             } else {
-                egui::Color32::from_rgb(80, 120, 200)
+                drop_block_for_target(world, locked, drag_entities, parent, entity)
             };
-            ui.painter().rect_filled(rect, 1.0, color);
-            let _ = hover;
+            *drop_target = Some(DropTarget::Before(entity));
+            let color = if drop_block.is_some() {
+                ERROR
+            } else {
+                SELECTION
+            };
+            ui.painter().line_segment(
+                [rect.left_center(), rect.right_center()],
+                egui::Stroke::new(2.0, color),
+            );
+            ui.painter().circle_filled(rect.left_center(), 3.5, color);
         }
     });
 }
 
+fn draw_attach_target_feedback(ui: &egui::Ui, rect: egui::Rect, invalid: bool) {
+    let color = if invalid { ERROR } else { ACCENT };
+    ui.painter().rect_filled(
+        rect,
+        2.0,
+        if invalid {
+            egui::Color32::from_rgba_premultiplied(105, 25, 29, 68)
+        } else {
+            egui::Color32::from_rgba_premultiplied(92, 66, 18, 62)
+        },
+    );
+    ui.painter().rect_stroke(
+        rect,
+        2.0,
+        egui::Stroke::new(2.0, color),
+        egui::StrokeKind::Inside,
+    );
+    if rect.width() > 150.0 {
+        ui.painter().text(
+            rect.right_center() - egui::vec2(7.0, 0.0),
+            egui::Align2::RIGHT_CENTER,
+            if invalid { "BLOCKED" } else { "ATTACH" },
+            egui::FontId::new(9.0, egui::FontFamily::Proportional),
+            color,
+        );
+    }
+}
+
 fn draw_generated_node(
     world: &World,
     ui: &mut egui::Ui,
@@ -558,8 +689,22 @@ fn draw_runtime_node(
         ui.add_space(18.0);
         let label = hierarchy_label_for_entity(world, entity, HierarchyNodeKind::Runtime);
         let selected = selected_entities.contains(entity);
+        let primary = selected_entities.as_slice().first().copied() == Some(entity);
         let color = if selected { TEXT_SELECTED } else { TEXT_DIM };
         let response = ui.selectable_label(selected, hierarchy_label_text(label, color));
+        if selected {
+            ui.painter().line_segment(
+                [response.rect.left_top(), response.rect.left_bottom()],
+                egui::Stroke::new(
+                    if primary { 3.0 } else { 2.0 },
+                    if primary {
+                        SELECTION
+                    } else {
+                        SELECTION_SECONDARY
+                    },
+                ),
+            );
+        }
         if response.clicked() {
             selected_entities.select_replace(entity);
         }
@@ -609,23 +754,62 @@ fn authored_context_menu(
     selected_entities: &mut SelectedEntities,
     renaming_entity: &mut Option<Entity>,
     rename_buffer: &mut String,
+    locked: &std::collections::HashSet<Entity>,
 ) {
-    if ui.button("Rename").clicked() {
+    let entity_locked = is_entity_locked(locked, entity);
+    let linked_read_only = is_linked_read_only(world, entity);
+    let prefab_member = world.get::<HydratedPrefabMember>(entity).is_some();
+    let entity_mutable = !entity_locked && !linked_read_only;
+    let selection_mutable = selected_entities.iter().all(|selected| {
+        !is_entity_locked(locked, selected) && !is_linked_read_only(world, selected)
+    });
+    if entity_locked {
+        ui.small(egui::RichText::new("Actor locked").color(TEXT_DIM));
+        ui.separator();
+    } else if linked_read_only {
+        ui.small(egui::RichText::new("Linked source member").color(TEXT_DIM));
+        ui.separator();
+    }
+    if ui
+        .add_enabled(entity_mutable, egui::Button::new("Rename"))
+        .clicked()
+    {
         *renaming_entity = Some(entity);
         *rename_buffer = entity_name(world, entity);
         ui.close();
     }
-    if ui.button("Duplicate").clicked() {
+    if ui
+        .add_enabled(entity_mutable, egui::Button::new("Duplicate"))
+        .clicked()
+    {
         duplicate_entities_with_history(world, &[entity]);
         ui.close();
     }
-    if ui.button("Delete").clicked() {
+    if ui
+        .add_enabled(entity_mutable, egui::Button::new("Delete"))
+        .clicked()
+    {
         delete_entities_with_history(world, &[entity]);
         ui.close();
     }
+    if prefab_member && !entity_locked {
+        if ui.button("Remove from prefab instance").clicked() {
+            crate::assets::prefab_overrides::remove_prefab_source_child(world, entity);
+            selected_entities.remove(entity);
+            ui.close();
+            return;
+        }
+        if ui.button("Unparent override").clicked() {
+            crate::assets::prefab_overrides::reparent_prefab_source_child(world, entity, None);
+            ui.close();
+            return;
+        }
+    }
     if selected_entities.len() >= 2
         && selected_entities.contains(entity)
-        && ui.button("Group").clicked()
+        && ui
+            .add_enabled(selection_mutable, egui::Button::new("Group"))
+            .clicked()
     {
         let entities: Vec<Entity> = selected_entities
             .iter()
@@ -634,11 +818,17 @@ fn authored_context_menu(
         group_selection_with_history(world, &entities);
         ui.close();
     }
-    if ui.button("Unparent").clicked() {
+    if ui
+        .add_enabled(entity_mutable, egui::Button::new("Unparent"))
+        .clicked()
+    {
         reparent_with_history(world, entity, None);
         ui.close();
     }
-    if ui.button("Create child Empty").clicked() {
+    let create_child = ui
+        .add_enabled(entity_mutable, egui::Button::new("Create child Empty"))
+        .on_disabled_hover_text("Locked and generated source actors cannot be modified");
+    if create_child.clicked() {
         create_empty_child_with_history(world, entity);
         ui.close();
     }
@@ -650,8 +840,167 @@ fn authored_context_menu(
     }
 }
 
-fn apply_drop(world: &mut World, drag: &HierarchyDragPayload, target: DropTarget, invalid: bool) {
-    if invalid || drag.entities.is_empty() {
+fn top_level_drag_entities(world: &World, candidates: &[Entity]) -> Vec<Entity> {
+    candidates
+        .iter()
+        .copied()
+        .filter(|entity| {
+            !candidates
+                .iter()
+                .copied()
+                .any(|other| other != *entity && is_ancestor(world, other, *entity))
+        })
+        .collect()
+}
+
+fn draggable_selection(
+    world: &World,
+    candidates: &[Entity],
+    locked: &std::collections::HashSet<Entity>,
+) -> Vec<Entity> {
+    let editable: Vec<_> = candidates
+        .iter()
+        .copied()
+        .filter(|entity| {
+            is_level_object(world, *entity)
+                && !is_entity_locked(locked, *entity)
+                && (!is_linked_read_only(world, *entity)
+                    || world.get::<HydratedPrefabMember>(*entity).is_some())
+        })
+        .collect();
+    top_level_drag_entities(world, &editable)
+}
+
+fn draw_hierarchy_drag_preview(
+    world: &World,
+    ui: &egui::Ui,
+    drag_entities: Option<&[Entity]>,
+    target: Option<DropTarget>,
+    block: Option<DropBlock>,
+) {
+    let Some(entities) = drag_entities.filter(|entities| !entities.is_empty()) else {
+        return;
+    };
+    let Some(pointer) = ui.input(|input| input.pointer.hover_pos()) else {
+        return;
+    };
+
+    let title = if entities.len() == 1 {
+        entity_name(world, entities[0])
+    } else {
+        format!("{} ACTORS", entities.len())
+    };
+    let action = if let Some(block) = block {
+        match block {
+            DropBlock::Hierarchy(HierarchyDropViolation::Cycle) => "Cannot attach: hierarchy cycle",
+            DropBlock::Hierarchy(HierarchyDropViolation::PrefabBoundary { .. }) => {
+                "Cannot attach: prefab contents are read-only"
+            }
+            DropBlock::LockedTarget(_) => "Cannot attach: target is locked",
+        }
+    } else {
+        match target {
+            Some(DropTarget::Root) => "Move to scene root",
+            Some(DropTarget::On(parent)) => {
+                return draw_hierarchy_drag_preview_card(
+                    ui,
+                    pointer,
+                    &title,
+                    &format!("Attach to {}", entity_name(world, parent)),
+                    false,
+                );
+            }
+            Some(DropTarget::Before(sibling)) => {
+                return draw_hierarchy_drag_preview_card(
+                    ui,
+                    pointer,
+                    &title,
+                    &format!("Insert before {}", entity_name(world, sibling)),
+                    false,
+                );
+            }
+            None => "Drop on an actor to attach",
+        }
+    };
+    draw_hierarchy_drag_preview_card(ui, pointer, &title, action, block.is_some());
+}
+
+fn draw_hierarchy_drag_preview_card(
+    ui: &egui::Ui,
+    pointer: egui::Pos2,
+    title: &str,
+    action: &str,
+    invalid: bool,
+) {
+    let content = ui.ctx().content_rect();
+    let pos = egui::pos2(
+        (pointer.x + 18.0).min(content.right() - 248.0),
+        (pointer.y + 18.0).min(content.bottom() - 58.0),
+    );
+    egui::Area::new(egui::Id::new("hierarchy_drag_preview"))
+        .fixed_pos(pos)
+        .default_size(egui::vec2(236.0, 56.0))
+        .order(egui::Order::Tooltip)
+        .interactable(false)
+        .show(ui.ctx(), |ui| {
+            ui.set_min_size(egui::vec2(236.0, 56.0));
+            ui.set_max_size(egui::vec2(236.0, 56.0));
+            overlay_chip_frame().show(ui, |ui| {
+                ui.set_width(218.0);
+                ui.horizontal(|ui| {
+                    ui.label(
+                        phosphor_icon(icons::TREE_STRUCTURE, 18.0).color(if invalid {
+                            ERROR
+                        } else {
+                            ACCENT
+                        }),
+                    );
+                    ui.vertical(|ui| {
+                        ui.spacing_mut().item_spacing.y = 1.0;
+                        ui.label(egui::RichText::new(title).strong().color(TEXT_SELECTED));
+                        ui.label(egui::RichText::new(action).size(11.0).color(if invalid {
+                            ERROR
+                        } else {
+                            TEXT_DIM
+                        }));
+                    });
+                });
+            });
+        });
+}
+
+fn apply_drop(
+    world: &mut World,
+    drag: &HierarchyDragPayload,
+    target: DropTarget,
+    block: Option<DropBlock>,
+) {
+    if block.is_some() || drag.entities.is_empty() {
+        return;
+    }
+    let prefab_members = drag
+        .entities
+        .iter()
+        .all(|entity| world.get::<HydratedPrefabMember>(*entity).is_some());
+    if prefab_members {
+        match target {
+            DropTarget::Root => {
+                crate::assets::prefab_overrides::reparent_prefab_source_children(
+                    world,
+                    &drag.entities,
+                    None,
+                );
+            }
+            DropTarget::On(parent) => {
+                crate::assets::prefab_overrides::reparent_prefab_source_children(
+                    world,
+                    &drag.entities,
+                    Some(parent),
+                );
+                expand_parent_after_drop(world, parent);
+            }
+            DropTarget::Before(_) => {}
+        }
         return;
     }
     match target {
@@ -660,14 +1009,18 @@ fn apply_drop(world: &mut World, drag: &HierarchyDragPayload, target: DropTarget
         }
         DropTarget::On(parent) => {
             reorder_siblings_with_history(world, &drag.entities, Some(parent), i32::MAX);
+            expand_parent_after_drop(world, parent);
         }
         DropTarget::Before(before) => {
             let parent = world
                 .get::<ChildOf>(before)
                 .map(|child_of| child_of.parent());
             let siblings = match parent {
-                Some(parent) => authored_children(world, parent),
-                None => level_object_roots(world),
+                Some(parent) => mutable_authored_children(world, parent),
+                None => level_object_roots(world)
+                    .into_iter()
+                    .filter(|entity| !is_linked_read_only(world, *entity))
+                    .collect(),
             };
             let insert_index = siblings
                 .iter()
@@ -678,6 +1031,53 @@ fn apply_drop(world: &mut World, drag: &HierarchyDragPayload, target: DropTarget
     }
 }
 
+fn drop_block_for_target(
+    world: &World,
+    locked: &std::collections::HashSet<Entity>,
+    drag_entities: &[Entity],
+    new_parent: Option<Entity>,
+    target: Entity,
+) -> Option<DropBlock> {
+    if is_entity_locked(locked, target)
+        || new_parent.is_some_and(|parent| is_entity_locked(locked, parent))
+    {
+        return Some(DropBlock::LockedTarget(target));
+    }
+    if is_linked_read_only(world, target) {
+        if world.get::<HydratedPrefabMember>(target).is_some()
+            && hierarchy_drop_violation(world, drag_entities, new_parent).is_none()
+        {
+            return None;
+        }
+        let root = crate::assets::prefab_overrides::prefab_member_override_target(world, target)
+            .map(|(root, _)| root)
+            .unwrap_or(target);
+        return Some(DropBlock::Hierarchy(
+            HierarchyDropViolation::PrefabBoundary { root },
+        ));
+    }
+    hierarchy_drop_violation(world, drag_entities, new_parent).map(DropBlock::Hierarchy)
+}
+
+fn expand_parent_after_drop(world: &mut World, parent: Entity) {
+    let path = entity_hierarchy_path(world, parent);
+    {
+        let mut state = world.resource_mut::<HierarchyPanelState>();
+        if state.expanded.insert(parent) {
+            state.mark_dirty();
+        }
+    }
+
+    let mut prefs = world.resource_mut::<UserPreferences>();
+    if !prefs
+        .hierarchy_expanded_paths
+        .iter()
+        .any(|entry| entry == &path)
+    {
+        prefs.hierarchy_expanded_paths.push(path);
+    }
+}
+
 fn subtree_matches_filter(
     world: &World,
     entity: Entity,
@@ -744,3 +1144,76 @@ pub(crate) fn is_runtime_hierarchy_entity(world: &World, entity: Entity) -> bool
                 || entity_ref.contains::<ProjectSun>())
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use shared::LevelObject;
+
+    #[test]
+    fn drag_selection_keeps_only_top_level_actors() {
+        let mut world = World::new();
+        let parent = world.spawn(LevelObject).id();
+        let child = world.spawn((LevelObject, ChildOf(parent))).id();
+        let peer = world.spawn(LevelObject).id();
+
+        let normalized = top_level_drag_entities(&world, &[parent, child, peer]);
+
+        assert_eq!(normalized, vec![parent, peer]);
+    }
+
+    #[test]
+    fn drag_selection_excludes_locked_actors_before_subtree_normalization() {
+        let mut world = World::new();
+        let parent = world.spawn(LevelObject).id();
+        let child = world.spawn((LevelObject, ChildOf(parent))).id();
+        let peer = world.spawn(LevelObject).id();
+        let locked = std::collections::HashSet::from([parent]);
+
+        let normalized = draggable_selection(&world, &[parent, child, peer], &locked);
+
+        assert_eq!(normalized, vec![child, peer]);
+    }
+
+    #[test]
+    fn locked_drop_target_reports_specific_block() {
+        let mut world = World::new();
+        let actor = world.spawn(LevelObject).id();
+        let target = world.spawn(LevelObject).id();
+        let locked = std::collections::HashSet::from([target]);
+
+        assert_eq!(
+            drop_block_for_target(&world, &locked, &[actor], Some(target), target),
+            Some(DropBlock::LockedTarget(target))
+        );
+    }
+
+    #[test]
+    fn deep_filtered_tree_keeps_matching_descendant_discoverable() {
+        let mut world = World::new();
+        let root = world.spawn((LevelObject, Name::new("Root"))).id();
+        let mut parent = root;
+        for depth in 0..64 {
+            parent = world
+                .spawn((
+                    LevelObject,
+                    Name::new(if depth == 63 { "Needle" } else { "Branch" }),
+                    ChildOf(parent),
+                ))
+                .id();
+        }
+
+        assert!(subtree_matches_filter(
+            &world,
+            root,
+            "needle",
+            HierarchySort::Manual
+        ));
+        assert!(!subtree_matches_filter(
+            &world,
+            root,
+            "missing",
+            HierarchySort::Manual
+        ));
+    }
+}
diff --git a/crates/editor/src/ui/hierarchy_ops.rs b/crates/editor/src/ui/hierarchy_ops.rs
index c1def6d..3706160 100644
--- a/crates/editor/src/ui/hierarchy_ops.rs
+++ b/crates/editor/src/ui/hierarchy_ops.rs
@@ -2,8 +2,8 @@
 
 use bevy::prelude::*;
 use shared::{
-    ActorKind, AuthoringLightKind, EditorVisibility, HierarchySiblingIndex, LevelObject, LightDesc,
-    ModelRef, PhysicsBody, PlayerSpawn,
+    ActorKind, AuthoringLightKind, EditorVisibility, HierarchySiblingIndex, HydratedPrefabMember,
+    LevelObject, LightDesc, ModelRef, PhysicsBody, PlayerSpawn, PrefabInstance,
 };
 
 use super::helpers::{entity_name, is_level_object, HierarchyNodeKind};
@@ -44,6 +44,66 @@ pub fn would_create_cycle(world: &World, targets: &[Entity], new_parent: Option<
         .any(|entity| is_ancestor(world, *entity, parent))
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum HierarchyDropViolation {
+    Cycle,
+    PrefabBoundary { root: Entity },
+}
+
+/// Returns the authored prefab-instance root containing `entity`, including the root itself.
+pub fn prefab_instance_boundary(world: &World, entity: Entity) -> Option<Entity> {
+    let mut current = Some(entity);
+    while let Some(candidate) = current {
+        if world.get::<PrefabInstance>(candidate).is_some() {
+            return Some(candidate);
+        }
+        current = world
+            .get::<ChildOf>(candidate)
+            .map(|child_of| child_of.parent())
+            .filter(|parent| is_level_object(world, *parent));
+    }
+    None
+}
+
+/// Authored local children may be attached to instances; hydrated source members remain read-only.
+pub fn hierarchy_drop_violation(
+    world: &World,
+    targets: &[Entity],
+    new_parent: Option<Entity>,
+) -> Option<HierarchyDropViolation> {
+    if would_create_cycle(world, targets, new_parent) {
+        return Some(HierarchyDropViolation::Cycle);
+    }
+    let prefab_targets: Vec<_> = targets
+        .iter()
+        .filter_map(|target| {
+            crate::assets::prefab_overrides::prefab_member_override_target(world, *target)
+        })
+        .collect();
+    if !prefab_targets.is_empty() {
+        let (root, path) = &prefab_targets[0];
+        let compatible_targets = prefab_targets.len() == targets.len()
+            && prefab_targets.iter().all(|(candidate_root, candidate)| {
+                candidate_root == root && candidate.instance_chain == path.instance_chain
+            });
+        let compatible_parent = new_parent.is_none_or(|parent| {
+            crate::assets::prefab_overrides::prefab_member_override_target(world, parent)
+                .is_some_and(|(parent_root, parent_path)| {
+                    parent_root == *root && parent_path.instance_chain == path.instance_chain
+                })
+        });
+        if compatible_targets && compatible_parent {
+            return None;
+        }
+        return Some(HierarchyDropViolation::PrefabBoundary { root: *root });
+    }
+    new_parent
+        .and_then(|parent| world.get::<HydratedPrefabMember>(parent))
+        .map(|owner| HierarchyDropViolation::PrefabBoundary {
+            root: owner.instance_root,
+        })
+}
+
 pub fn level_object_roots(world: &mut World) -> Vec<Entity> {
     let mut query = world.query_filtered::<(Entity, Option<&ChildOf>), With<LevelObject>>();
     query
@@ -67,6 +127,30 @@ pub fn authored_children(world: &World, parent: Entity) -> Vec<Entity> {
         .unwrap_or_default()
 }
 
+pub fn mutable_authored_children(world: &World, parent: Entity) -> Vec<Entity> {
+    authored_children(world, parent)
+        .into_iter()
+        .filter(|entity| {
+            world.get::<HydratedPrefabMember>(*entity).is_none()
+                && world
+                    .get::<crate::scene_io::ComposedSceneMember>(*entity)
+                    .is_none()
+        })
+        .collect()
+}
+
+fn mutable_level_object_roots(world: &mut World) -> Vec<Entity> {
+    level_object_roots(world)
+        .into_iter()
+        .filter(|entity| {
+            world.get::<HydratedPrefabMember>(*entity).is_none()
+                && world
+                    .get::<crate::scene_io::ComposedSceneMember>(*entity)
+                    .is_none()
+        })
+        .collect()
+}
+
 fn entity_tie_break(a: Entity, b: Entity) -> std::cmp::Ordering {
     a.to_bits().cmp(&b.to_bits())
 }
@@ -75,8 +159,9 @@ pub fn sort_siblings(world: &World, entities: &mut [Entity], sort_mode: Hierarch
     match sort_mode {
         HierarchySort::Manual => {
             entities.sort_by(|a, b| {
-                sibling_index(world, *a)
-                    .cmp(&sibling_index(world, *b))
+                linked_order_class(world, *a)
+                    .cmp(&linked_order_class(world, *b))
+                    .then_with(|| sibling_index(world, *a).cmp(&sibling_index(world, *b)))
                     .then_with(|| entity_tie_break(*a, *b))
             });
         }
@@ -100,6 +185,18 @@ pub fn sort_siblings(world: &World, entities: &mut [Entity], sort_mode: Hierarch
     }
 }
 
+fn linked_order_class(world: &World, entity: Entity) -> u8 {
+    if world.get::<HydratedPrefabMember>(entity).is_some()
+        || world
+            .get::<crate::scene_io::ComposedSceneMember>(entity)
+            .is_some()
+    {
+        0
+    } else {
+        1
+    }
+}
+
 fn actor_kind_sort_key(world: &World, entity: Entity) -> u8 {
     world
         .get::<ActorKind>(entity)
@@ -108,6 +205,7 @@ fn actor_kind_sort_key(world: &World, entity: Entity) -> u8 {
             ActorKind::Empty => 0,
             ActorKind::Brush | ActorKind::StaticMesh | ActorKind::ImportedModel => 1,
             ActorKind::Light => 2,
+            ActorKind::AudioSource | ActorKind::AudioListener => 3,
             ActorKind::PrefabAnchor => 3,
             ActorKind::PlayerSpawn => 4,
             ActorKind::WeaponSpawn => 5,
@@ -160,6 +258,7 @@ pub fn renumber_siblings(world: &mut World, parent: Option<Entity>, ordered: &[E
 }
 
 pub fn capture_sibling_state(world: &World, entity: Entity) -> SiblingChange {
+    let transform = world.get::<Transform>(entity).copied();
     SiblingChange {
         entity,
         old_parent: world
@@ -170,6 +269,8 @@ pub fn capture_sibling_state(world: &World, entity: Entity) -> SiblingChange {
             .map(|child_of| child_of.parent()),
         old_index: sibling_index(world, entity),
         new_index: sibling_index(world, entity),
+        old_transform: transform,
+        new_transform: transform,
     }
 }
 
@@ -181,6 +282,9 @@ pub fn apply_sibling_change(world: &mut World, change: &SiblingChange) {
             entity_mut.remove::<ChildOf>();
         }
         entity_mut.insert(HierarchySiblingIndex(change.old_index));
+        if let Some(transform) = change.old_transform {
+            entity_mut.insert(transform);
+        }
     }
 }
 
@@ -192,6 +296,9 @@ pub fn apply_sibling_change_new(world: &mut World, change: &SiblingChange) {
             entity_mut.remove::<ChildOf>();
         }
         entity_mut.insert(HierarchySiblingIndex(change.new_index));
+        if let Some(transform) = change.new_transform {
+            entity_mut.insert(transform);
+        }
     }
 }
 
@@ -235,8 +342,8 @@ fn renumber_inserted_siblings(
     insert_index: i32,
 ) -> Vec<SiblingChange> {
     let mut siblings = match new_parent {
-        Some(parent) => authored_children(world, parent),
-        None => level_object_roots(world),
+        Some(parent) => mutable_authored_children(world, parent),
+        None => mutable_level_object_roots(world),
     };
     siblings.retain(|entity| !moving.contains(entity));
     let insert = insert_index.clamp(0, siblings.len() as i32) as usize;
@@ -252,8 +359,8 @@ fn renumber_existing_siblings(
     exclude: &[Entity],
 ) -> Vec<SiblingChange> {
     let mut siblings = match parent {
-        Some(parent) => authored_children(world, parent),
-        None => level_object_roots(world),
+        Some(parent) => mutable_authored_children(world, parent),
+        None => mutable_level_object_roots(world),
     };
     siblings.retain(|entity| !exclude.contains(entity));
     sort_siblings(world, &mut siblings, HierarchySort::Manual);
@@ -272,6 +379,20 @@ fn apply_sibling_order(
             .map(|child_of| child_of.parent());
         let old_index = sibling_index(world, *entity);
         let new_index = index as i32;
+        let old_transform = world.get::<Transform>(*entity).copied();
+        let new_transform = if old_parent != parent {
+            world
+                .get::<GlobalTransform>(*entity)
+                .map(|global| {
+                    match parent.and_then(|parent| world.get::<GlobalTransform>(parent)) {
+                        Some(parent_global) => global.reparented_to(parent_global),
+                        None => global.compute_transform(),
+                    }
+                })
+                .or(old_transform)
+        } else {
+            old_transform
+        };
         if old_parent != parent || old_index != new_index {
             changes.push(SiblingChange {
                 entity: *entity,
@@ -279,6 +400,8 @@ fn apply_sibling_order(
                 new_parent: parent,
                 old_index,
                 new_index,
+                old_transform,
+                new_transform,
             });
         }
         if let Ok(mut entity_mut) = world.get_entity_mut(*entity) {
@@ -288,6 +411,9 @@ fn apply_sibling_order(
                 entity_mut.remove::<ChildOf>();
             }
             entity_mut.insert(HierarchySiblingIndex(new_index));
+            if let Some(transform) = new_transform {
+                entity_mut.insert(transform);
+            }
         }
     }
     changes
@@ -340,6 +466,8 @@ pub fn actor_kind_icon(kind: ActorKind) -> &'static str {
         ActorKind::StaticMesh => icons::CUBE.as_str(),
         ActorKind::ImportedModel => icons::CUBE_TRANSPARENT.as_str(),
         ActorKind::Light => icons::LIGHTBULB.as_str(),
+        ActorKind::AudioSource => icons::SPEAKER_HIGH.as_str(),
+        ActorKind::AudioListener => icons::HEADPHONES.as_str(),
         ActorKind::PrefabAnchor => icons::PACKAGE.as_str(),
         ActorKind::PlayerSpawn => icons::USER_CIRCLE.as_str(),
         ActorKind::WeaponSpawn => icons::CROSSHAIR.as_str(),
@@ -434,6 +562,7 @@ pub fn is_entity_locked(locked: &std::collections::HashSet<Entity>, entity: Enti
 #[cfg(test)]
 mod tests {
     use super::*;
+    use shared::ActorId;
 
     #[test]
     fn sort_by_name_is_stable_for_duplicate_names() {
@@ -448,4 +577,99 @@ mod tests {
         sort_siblings(&world, &mut entities, HierarchySort::Name);
         assert_eq!(entities, first, "duplicate-name sort must be deterministic");
     }
+
+    #[test]
+    fn reparent_preserves_world_transform_and_round_trips_history() {
+        let mut world = World::new();
+        let parent = world
+            .spawn((
+                LevelObject,
+                Transform::from_xyz(10.0, 0.0, 0.0),
+                GlobalTransform::from_xyz(10.0, 0.0, 0.0),
+                HierarchySiblingIndex(0),
+            ))
+            .id();
+        let child = world
+            .spawn((
+                LevelObject,
+                Transform::from_xyz(12.0, 1.0, -3.0),
+                GlobalTransform::from_xyz(12.0, 1.0, -3.0),
+                HierarchySiblingIndex(1),
+            ))
+            .id();
+
+        let changes = reorder_entities_under_parent(&mut world, &[child], Some(parent), 0);
+        let child_change = changes
+            .iter()
+            .find(|change| change.entity == child)
+            .expect("reparent should record the moved actor");
+
+        assert_eq!(world.get::<ChildOf>(child).unwrap().parent(), parent);
+        assert_eq!(
+            world.get::<Transform>(child).unwrap().translation,
+            Vec3::new(2.0, 1.0, -3.0)
+        );
+
+        apply_sibling_change(&mut world, child_change);
+        assert!(world.get::<ChildOf>(child).is_none());
+        assert_eq!(
+            world.get::<Transform>(child).unwrap().translation,
+            Vec3::new(12.0, 1.0, -3.0)
+        );
+
+        apply_sibling_change_new(&mut world, child_change);
+        assert_eq!(world.get::<ChildOf>(child).unwrap().parent(), parent);
+        assert_eq!(
+            world.get::<Transform>(child).unwrap().translation,
+            Vec3::new(2.0, 1.0, -3.0)
+        );
+    }
+
+    #[test]
+    fn cycle_detection_rejects_descendant_parent() {
+        let mut world = World::new();
+        let parent = world.spawn(LevelObject).id();
+        let child = world.spawn((LevelObject, ChildOf(parent))).id();
+
+        assert!(would_create_cycle(&world, &[parent], Some(child)));
+        assert!(!would_create_cycle(&world, &[child], None));
+    }
+
+    #[test]
+    fn prefab_boundary_allows_local_and_same_layer_override_structure() {
+        let mut world = World::new();
+        let instance = world.spawn((LevelObject, PrefabInstance::default())).id();
+        let local_child = world.spawn((LevelObject, ChildOf(instance))).id();
+        let generated_child = world
+            .spawn((
+                LevelObject,
+                ActorId::new("generated-child"),
+                ChildOf(instance),
+                HydratedPrefabMember {
+                    instance_root: instance,
+                },
+            ))
+            .id();
+        let actor = world.spawn(LevelObject).id();
+        let nested_instance = world.spawn((LevelObject, PrefabInstance::default())).id();
+
+        assert_eq!(
+            hierarchy_drop_violation(&world, &[actor], Some(instance)),
+            None
+        );
+        assert_eq!(
+            hierarchy_drop_violation(&world, &[nested_instance], Some(local_child)),
+            None
+        );
+        assert_eq!(
+            hierarchy_drop_violation(&world, &[nested_instance], Some(generated_child)),
+            Some(HierarchyDropViolation::PrefabBoundary { root: instance })
+        );
+        assert_eq!(
+            hierarchy_drop_violation(&world, &[generated_child], None),
+            None
+        );
+        assert_eq!(hierarchy_drop_violation(&world, &[instance], None), None);
+        assert_eq!(hierarchy_drop_violation(&world, &[local_child], None), None);
+    }
 }
diff --git a/crates/editor/src/ui/inspector.rs b/crates/editor/src/ui/inspector.rs
index 61ab8bb..9313c64 100644
--- a/crates/editor/src/ui/inspector.rs
+++ b/crates/editor/src/ui/inspector.rs
@@ -8,22 +8,26 @@ use bevy_egui::egui;
 use egui_phosphor_icons::{icons, Icon};
 use shared::{
     brush_math::{validate_brush, BrushDiagnosticSeverity},
-    inspector_component_active, AuthoringLightKind, AuthoringRigidBody, BrushDesc, BrushKind,
-    ColliderDesc, ColliderShapeDesc, ColorDesc, ComponentInstanceId, EditorAssetRef,
+    infer_actor_kind, inspector_component_active, ActorKind, AnimationControllerDesc,
+    AudioListenerDesc, AudioSourceDesc, AuthoringLightKind, AuthoringRigidBody, BrushDesc,
+    BrushKind, ColliderDesc, ColliderShapeDesc, ColorDesc, ComponentInstanceId, EditorAssetRef,
     InspectorOrder, LevelObject, LightDesc, MaterialDesc, MaterialParameter,
-    MaterialParameterValue, MaterialShaderKind, ObjectiveMarker, PhysicsBody, PlayerSpawn,
-    PostProcessVolumeDesc, PrefabInstance, Primitive, PrimitiveShape, ProjectSun, RigidBodyDesc,
-    StaticMeshRenderer, StaticMeshRendererEntry, TeamSpawn, TriggerVolume, WeaponSpawn,
-    AUTHORING_DIRECTIONAL_LUX_MAX, AUTHORING_POINT_SPOT_LUMENS_MAX, COMPONENT_BRUSH_DESC,
-    COMPONENT_COLLIDER_DESC, COMPONENT_LIGHT_DESC, COMPONENT_MATERIAL_DESC,
-    COMPONENT_OBJECTIVE_MARKER, COMPONENT_PHYSICS_BODY, COMPONENT_PLAYER_SPAWN,
-    COMPONENT_POST_PROCESS_VOLUME, COMPONENT_PREFAB_INSTANCE, COMPONENT_PRIMITIVE,
-    COMPONENT_PROJECT_SUN, COMPONENT_RIGID_BODY_DESC, COMPONENT_STATIC_MESH_RENDERER,
-    COMPONENT_TEAM_SPAWN, COMPONENT_TRIGGER_VOLUME, COMPONENT_WEAPON_SPAWN,
+    MaterialParameterValue, MaterialShaderKind, ModelRef, ObjectiveMarker, PhysicsBody,
+    PlayerSpawn, PostProcessVolumeDesc, PrefabInstance, Primitive, PrimitiveShape, ProjectSun,
+    RigidBodyDesc, StaticMeshRenderer, StaticMeshRendererEntry, TeamSpawn, TriggerVolume,
+    WeaponSpawn, AUTHORING_DIRECTIONAL_LUX_MAX, AUTHORING_POINT_SPOT_LUMENS_MAX,
+    COMPONENT_ANIMATION_CONTROLLER_DESC, COMPONENT_AUDIO_LISTENER_DESC,
+    COMPONENT_AUDIO_SOURCE_DESC, COMPONENT_BRUSH_DESC, COMPONENT_COLLIDER_DESC,
+    COMPONENT_LIGHT_DESC, COMPONENT_MATERIAL_DESC, COMPONENT_OBJECTIVE_MARKER,
+    COMPONENT_PHYSICS_BODY, COMPONENT_PLAYER_SPAWN, COMPONENT_POST_PROCESS_VOLUME,
+    COMPONENT_PREFAB_INSTANCE, COMPONENT_PRIMITIVE, COMPONENT_PROJECT_SUN,
+    COMPONENT_RIGID_BODY_DESC, COMPONENT_STATIC_MESH_RENDERER, COMPONENT_TEAM_SPAWN,
+    COMPONENT_TRIGGER_VOLUME, COMPONENT_WEAPON_SPAWN,
 };
 
 use crate::history::{
-    material_eq, set_brush_with_history, set_collider_with_history,
+    material_eq, set_animation_controller_with_history, set_audio_listener_with_history,
+    set_audio_source_with_history, set_brush_with_history, set_collider_with_history,
     set_inspector_order_with_history, set_light_with_history, set_material_with_history,
     set_physics_with_history, set_post_process_volume_with_history, set_primitive_with_history,
     set_rigid_body_with_history, set_static_mesh_renderer_with_history, EditorEntitySnapshot,
@@ -134,11 +138,14 @@ enum AddComponentShelfDirection {
 
 #[derive(Debug, Clone)]
 enum CopiedComponent {
+    AnimationControllerDesc(AnimationControllerDesc),
     Primitive(Primitive),
     BrushDesc(BrushDesc),
     StaticMeshRenderer(StaticMeshRenderer),
     MaterialDesc(MaterialDesc),
     LightDesc(LightDesc),
+    AudioSourceDesc(AudioSourceDesc),
+    AudioListenerDesc(AudioListenerDesc),
     RigidBodyDesc(RigidBodyDesc),
     ColliderDesc(ColliderDesc),
     PhysicsBody(PhysicsBody),
@@ -153,11 +160,14 @@ enum CopiedComponent {
 impl CopiedComponent {
     fn type_name(&self) -> &'static str {
         match self {
+            Self::AnimationControllerDesc(_) => COMPONENT_ANIMATION_CONTROLLER_DESC,
             Self::Primitive(_) => COMPONENT_PRIMITIVE,
             Self::BrushDesc(_) => COMPONENT_BRUSH_DESC,
             Self::StaticMeshRenderer(_) => COMPONENT_STATIC_MESH_RENDERER,
             Self::MaterialDesc(_) => COMPONENT_MATERIAL_DESC,
             Self::LightDesc(_) => COMPONENT_LIGHT_DESC,
+            Self::AudioSourceDesc(_) => COMPONENT_AUDIO_SOURCE_DESC,
+            Self::AudioListenerDesc(_) => COMPONENT_AUDIO_LISTENER_DESC,
             Self::RigidBodyDesc(_) => COMPONENT_RIGID_BODY_DESC,
             Self::ColliderDesc(_) => COMPONENT_COLLIDER_DESC,
             Self::PhysicsBody(_) => COMPONENT_PHYSICS_BODY,
@@ -357,6 +367,9 @@ fn component_card_key(world: &World, entity: Entity, type_name: &str) -> String
 
 fn present_component_type_names(world: &World, entity: Entity) -> Vec<&'static str> {
     let mut present = Vec::new();
+    if world.get::<AnimationControllerDesc>(entity).is_some() {
+        present.push(COMPONENT_ANIMATION_CONTROLLER_DESC);
+    }
     if world.get::<StaticMeshRenderer>(entity).is_some() {
         present.push(COMPONENT_STATIC_MESH_RENDERER);
     }
@@ -372,6 +385,12 @@ fn present_component_type_names(world: &World, entity: Entity) -> Vec<&'static s
     if world.get::<LightDesc>(entity).is_some() {
         present.push(COMPONENT_LIGHT_DESC);
     }
+    if world.get::<AudioSourceDesc>(entity).is_some() {
+        present.push(COMPONENT_AUDIO_SOURCE_DESC);
+    }
+    if world.get::<AudioListenerDesc>(entity).is_some() {
+        present.push(COMPONENT_AUDIO_LISTENER_DESC);
+    }
     if world.get::<RigidBodyDesc>(entity).is_some() {
         present.push(COMPONENT_RIGID_BODY_DESC);
     }
@@ -410,6 +429,10 @@ fn present_component_type_names(world: &World, entity: Entity) -> Vec<&'static s
 
 fn copy_component(world: &mut World, entity: Entity, type_name: &str) {
     let component = match type_name {
+        COMPONENT_ANIMATION_CONTROLLER_DESC => world
+            .get::<AnimationControllerDesc>(entity)
+            .cloned()
+            .map(CopiedComponent::AnimationControllerDesc),
         COMPONENT_PRIMITIVE => world
             .get::<Primitive>(entity)
             .cloned()
@@ -430,6 +453,14 @@ fn copy_component(world: &mut World, entity: Entity, type_name: &str) {
             .get::<LightDesc>(entity)
             .cloned()
             .map(CopiedComponent::LightDesc),
+        COMPONENT_AUDIO_SOURCE_DESC => world
+            .get::<AudioSourceDesc>(entity)
+            .cloned()
+            .map(CopiedComponent::AudioSourceDesc),
+        COMPONENT_AUDIO_LISTENER_DESC => world
+            .get::<AudioListenerDesc>(entity)
+            .copied()
+            .map(CopiedComponent::AudioListenerDesc),
         COMPONENT_RIGID_BODY_DESC => world
             .get::<RigidBodyDesc>(entity)
             .copied()
@@ -478,6 +509,11 @@ fn paste_component(world: &mut World, entity: Entity, type_name: &str) {
         .get_resource::<InspectorClipboard>()
         .and_then(|clipboard| clipboard.component.clone());
     match component {
+        Some(CopiedComponent::AnimationControllerDesc(value))
+            if type_name == COMPONENT_ANIMATION_CONTROLLER_DESC =>
+        {
+            set_animation_controller_with_history(world, entity, value);
+        }
         Some(CopiedComponent::Primitive(value)) if type_name == COMPONENT_PRIMITIVE => {
             set_primitive_with_history(world, entity, value);
         }
@@ -495,6 +531,16 @@ fn paste_component(world: &mut World, entity: Entity, type_name: &str) {
         Some(CopiedComponent::LightDesc(value)) if type_name == COMPONENT_LIGHT_DESC => {
             set_light_with_history(world, entity, value);
         }
+        Some(CopiedComponent::AudioSourceDesc(value))
+            if type_name == COMPONENT_AUDIO_SOURCE_DESC =>
+        {
+            set_audio_source_with_history(world, entity, value);
+        }
+        Some(CopiedComponent::AudioListenerDesc(value))
+            if type_name == COMPONENT_AUDIO_LISTENER_DESC =>
+        {
+            set_audio_listener_with_history(world, entity, value);
+        }
         Some(CopiedComponent::RigidBodyDesc(value)) if type_name == COMPONENT_RIGID_BODY_DESC => {
             set_rigid_body_with_history(world, entity, value);
         }
@@ -532,6 +578,11 @@ fn paste_component(world: &mut World, entity: Entity, type_name: &str) {
 
 fn reset_component(world: &mut World, entity: Entity, type_name: &str) {
     match type_name {
+        COMPONENT_ANIMATION_CONTROLLER_DESC => {
+            let controller =
+                crate::ui::animation_inspector::default_controller_for_actor(world, entity);
+            set_animation_controller_with_history(world, entity, controller);
+        }
         COMPONENT_PRIMITIVE => set_primitive_with_history(world, entity, Primitive::default()),
         COMPONENT_BRUSH_DESC => set_brush_with_history(world, entity, BrushDesc::default()),
         COMPONENT_STATIC_MESH_RENDERER => {
@@ -541,6 +592,12 @@ fn reset_component(world: &mut World, entity: Entity, type_name: &str) {
             set_material_with_history(world, entity, MaterialDesc::default())
         }
         COMPONENT_LIGHT_DESC => set_light_with_history(world, entity, LightDesc::default()),
+        COMPONENT_AUDIO_SOURCE_DESC => {
+            set_audio_source_with_history(world, entity, AudioSourceDesc::default())
+        }
+        COMPONENT_AUDIO_LISTENER_DESC => {
+            set_audio_listener_with_history(world, entity, AudioListenerDesc::default())
+        }
         COMPONENT_RIGID_BODY_DESC => {
             set_rigid_body_with_history(world, entity, RigidBodyDesc::default());
         }
@@ -586,8 +643,17 @@ fn remove_registered_component(world: &mut World, entity: Entity, type_name: &st
     let Some(before) = crate::history::snapshot_entity(world, entity) else {
         return;
     };
+    let removed_dedicated_audio_kind = matches!(
+        (type_name, before.actor_kind),
+        (COMPONENT_AUDIO_SOURCE_DESC, ActorKind::AudioSource)
+            | (COMPONENT_AUDIO_LISTENER_DESC, ActorKind::AudioListener)
+    );
     let removed = if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
         match type_name {
+            COMPONENT_ANIMATION_CONTROLLER_DESC if before.animation_controller.is_some() => {
+                entity_mut.remove::<AnimationControllerDesc>();
+                true
+            }
             COMPONENT_PRIMITIVE if before.primitive.is_some() => {
                 entity_mut.remove::<Primitive>();
                 true
@@ -608,6 +674,14 @@ fn remove_registered_component(world: &mut World, entity: Entity, type_name: &st
                 entity_mut.remove::<LightDesc>();
                 true
             }
+            COMPONENT_AUDIO_SOURCE_DESC if before.audio_source.is_some() => {
+                entity_mut.remove::<AudioSourceDesc>();
+                true
+            }
+            COMPONENT_AUDIO_LISTENER_DESC if before.audio_listener.is_some() => {
+                entity_mut.remove::<AudioListenerDesc>();
+                true
+            }
             COMPONENT_RIGID_BODY_DESC if before.rigid_body.is_some() => {
                 entity_mut.remove::<RigidBodyDesc>();
                 true
@@ -656,6 +730,19 @@ fn remove_registered_component(world: &mut World, entity: Entity, type_name: &st
     if !removed {
         return;
     }
+    if type_name == COMPONENT_ANIMATION_CONTROLLER_DESC {
+        crate::ui::animation_inspector::stop_preview_if_actor(world, entity);
+    }
+    if removed_dedicated_audio_kind {
+        let fallback = world
+            .get_entity(entity)
+            .ok()
+            .and_then(infer_actor_kind)
+            .unwrap_or(ActorKind::Empty);
+        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.insert(fallback);
+        }
+    }
     if let Some(after) = crate::history::snapshot_entity(world, entity) {
         let snapshot = diff_added(&after, &before);
         crate::history::push_command(
@@ -690,11 +777,20 @@ fn draw_authoring_component_by_type(
     type_name: &'static str,
 ) {
     match type_name {
+        COMPONENT_ANIMATION_CONTROLLER_DESC => {
+            crate::ui::animation_inspector::animation_controller_inspector_ui(world, ui, entity);
+        }
         COMPONENT_STATIC_MESH_RENDERER => static_mesh_renderer_ui(world, ui, entity),
         COMPONENT_BRUSH_DESC => brush_editor_ui(world, ui, entity),
         COMPONENT_PRIMITIVE => primitive_editor_ui(world, ui, entity),
         COMPONENT_MATERIAL_DESC => material_editor_ui(world, ui, entity),
         COMPONENT_LIGHT_DESC => light_editor_ui(world, ui, entity),
+        COMPONENT_AUDIO_SOURCE_DESC => {
+            crate::ui::audio_inspector::audio_source_inspector_ui(world, ui, entity);
+        }
+        COMPONENT_AUDIO_LISTENER_DESC => {
+            crate::ui::audio_inspector::audio_listener_inspector_ui(world, ui, entity);
+        }
         COMPONENT_RIGID_BODY_DESC => rigid_body_editor_ui(world, ui, entity),
         COMPONENT_COLLIDER_DESC => collider_editor_ui(world, ui, entity),
         COMPONENT_PHYSICS_BODY => physics_editor_ui(world, ui, entity),
@@ -982,6 +1078,8 @@ fn filtered_component_descriptors<'a>(
     [
         EditorComponentCategory::Authoring,
         EditorComponentCategory::Rendering,
+        EditorComponentCategory::Animation,
+        EditorComponentCategory::Audio,
         EditorComponentCategory::Physics,
         EditorComponentCategory::Gameplay,
         EditorComponentCategory::Volumes,
@@ -1002,6 +1100,8 @@ fn component_category_label(category: EditorComponentCategory) -> &'static str {
     match category {
         EditorComponentCategory::Authoring => "Authoring",
         EditorComponentCategory::Rendering => "Rendering",
+        EditorComponentCategory::Animation => "Animation",
+        EditorComponentCategory::Audio => "Audio",
         EditorComponentCategory::Physics => "Physics",
         EditorComponentCategory::Gameplay => "Gameplay",
         EditorComponentCategory::Volumes => "Volumes",
@@ -1046,8 +1146,15 @@ fn component_add_state(
         .copied()
         .filter(|type_name| !component_present(world, entity, type_name))
         .collect::<Vec<_>>();
+    let animation_target_missing = descriptor.type_name == COMPONENT_ANIMATION_CONTROLLER_DESC
+        && (!world
+            .get::<ActorKind>(entity)
+            .is_some_and(|kind| *kind == ActorKind::ImportedModel)
+            || world.get::<ModelRef>(entity).is_none());
     let reason = if duplicate {
         Some("Already present on this actor.".to_string())
+    } else if animation_target_missing {
+        Some("Animation Controller requires an ImportedModel actor with ModelRef.".to_string())
     } else if !conflicts.is_empty() {
         Some(format!(
             "Conflicts with {}.",
@@ -1110,6 +1217,9 @@ fn component_display_name(
 
 fn component_present(world: &World, entity: Entity, type_name: &str) -> bool {
     match type_name {
+        COMPONENT_ANIMATION_CONTROLLER_DESC => {
+            world.get::<AnimationControllerDesc>(entity).is_some()
+        }
         "shared::components::Primitive" => world.get::<Primitive>(entity).is_some(),
         "shared::components::BrushDesc" => world.get::<BrushDesc>(entity).is_some(),
         "shared::components::StaticMeshRenderer" => {
@@ -1117,6 +1227,8 @@ fn component_present(world: &World, entity: Entity, type_name: &str) -> bool {
         }
         "shared::components::MaterialDesc" => world.get::<MaterialDesc>(entity).is_some(),
         "shared::components::LightDesc" => world.get::<LightDesc>(entity).is_some(),
+        "shared::components::AudioSourceDesc" => world.get::<AudioSourceDesc>(entity).is_some(),
+        "shared::components::AudioListenerDesc" => world.get::<AudioListenerDesc>(entity).is_some(),
         "shared::components::RigidBodyDesc" => world.get::<RigidBodyDesc>(entity).is_some(),
         "shared::components::ColliderDesc" => world.get::<ColliderDesc>(entity).is_some(),
         "shared::components::PlayerSpawn" => world.get::<PlayerSpawn>(entity).is_some(),
@@ -1133,6 +1245,13 @@ fn component_present(world: &World, entity: Entity, type_name: &str) -> bool {
 
 fn insert_registered_component(world: &mut World, entity: Entity, type_name: &str) {
     match type_name {
+        COMPONENT_ANIMATION_CONTROLLER_DESC => {
+            let controller =
+                crate::ui::animation_inspector::default_controller_for_actor(world, entity);
+            insert_component(world, entity, move |world, e| {
+                world.entity_mut(e).insert(controller);
+            });
+        }
         "shared::components::Primitive" => insert_component(world, entity, |world, e| {
             world
                 .entity_mut(e)
@@ -1154,6 +1273,17 @@ fn insert_registered_component(world: &mut World, entity: Entity, type_name: &st
         "shared::components::LightDesc" => insert_component(world, entity, |world, e| {
             world.entity_mut(e).insert(LightDesc::default());
         }),
+        "shared::components::AudioSourceDesc" => insert_component(world, entity, |world, e| {
+            world
+                .entity_mut(e)
+                .insert((shared::ActorKind::AudioSource, AudioSourceDesc::default()));
+        }),
+        "shared::components::AudioListenerDesc" => insert_component(world, entity, |world, e| {
+            world.entity_mut(e).insert((
+                shared::ActorKind::AudioListener,
+                AudioListenerDesc::default(),
+            ));
+        }),
         "shared::components::RigidBodyDesc" => insert_component(world, entity, |world, e| {
             world.entity_mut(e).insert(RigidBodyDesc::default());
         }),
@@ -1234,6 +1364,17 @@ fn diff_added(before: &EditorEntitySnapshot, after: &EditorEntitySnapshot) -> Ed
         collider: after.collider.clone().filter(|_| before.collider.is_none()),
         physics: after.physics.clone().filter(|_| before.physics.is_none()),
         light: after.light.clone().filter(|_| before.light.is_none()),
+        animation_controller: after
+            .animation_controller
+            .clone()
+            .filter(|_| before.animation_controller.is_none()),
+        audio_source: after
+            .audio_source
+            .clone()
+            .filter(|_| before.audio_source.is_none()),
+        audio_listener: after
+            .audio_listener
+            .filter(|_| before.audio_listener.is_none()),
         player_spawn: after.player_spawn && !before.player_spawn,
         model: after.model.clone().filter(|_| before.model.is_none()),
         prefab: after.prefab.clone().filter(|_| before.prefab.is_none()),
diff --git a/crates/editor/src/ui/menu.rs b/crates/editor/src/ui/menu.rs
index b82a5a6..8619c93 100644
--- a/crates/editor/src/ui/menu.rs
+++ b/crates/editor/src/ui/menu.rs
@@ -45,6 +45,25 @@ pub fn top_menu_bar(
                     world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::SaveAs);
                     ui.close();
                 }
+                let recovery_available = world.resource::<SceneIo>().recovery_snapshot.is_some();
+                if recovery_available {
+                    ui.separator();
+                    if menu_item(ui, "Restore Recovery Snapshot", None, true).clicked() {
+                        world.resource_mut::<SceneIo>().request =
+                            Some(SceneIoRequest::RestoreRecovery);
+                        ui.close();
+                    }
+                    if menu_item(ui, "Save Recovery Copy As...", None, true).clicked() {
+                        world.resource_mut::<SceneIo>().request =
+                            Some(SceneIoRequest::SaveRecoveryCopyAs);
+                        ui.close();
+                    }
+                    if menu_item(ui, "Discard Recovery Snapshot", None, true).clicked() {
+                        world.resource_mut::<SceneIo>().request =
+                            Some(SceneIoRequest::DiscardRecovery);
+                        ui.close();
+                    }
+                }
                 ui.separator();
                 if menu_item(ui, "Import Assets...", None, true).clicked() {
                     world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::ImportAssets);
@@ -59,6 +78,24 @@ pub fn top_menu_bar(
                         Some(SceneIoRequest::SaveSelectionAsPrefab);
                     ui.close();
                 }
+                ui.separator();
+                if menu_item(ui, "Switch Project...", None, true).clicked() {
+                    world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::SwitchProject);
+                    ui.close();
+                }
+                if menu_item(ui, "Reveal Project Folder", None, true).clicked() {
+                    let root = world
+                        .resource::<crate::project_io::ProjectWorkspace>()
+                        .root
+                        .clone();
+                    let status =
+                        match crate::launcher::reveal_project_root(std::path::Path::new(&root)) {
+                            Ok(()) => format!("Revealed project folder {root}"),
+                            Err(error) => format!("Reveal project folder failed: {error}"),
+                        };
+                    world.resource_mut::<SceneIo>().set_status(status);
+                    ui.close();
+                }
                 let recent: Vec<(usize, String)> = world
                     .resource::<SceneIo>()
                     .recent_paths
@@ -123,6 +160,30 @@ pub fn top_menu_bar(
                 }
             });
 
+            ui.menu_button("Build", |ui| {
+                let running = world.resource::<super::build::BuildPanel>().is_running();
+                if menu_item(ui, "Build Package", None, !running).clicked() {
+                    open_and_focus_tab(dock_state, EditorTab::Build, panel_nodes);
+                    super::build::request_build(world, false);
+                    ui.close();
+                }
+                if menu_item(ui, "Build and Run", None, !running).clicked() {
+                    open_and_focus_tab(dock_state, EditorTab::Build, panel_nodes);
+                    super::build::request_build(world, true);
+                    ui.close();
+                }
+                if menu_item(ui, "Cancel Build", None, running).clicked() {
+                    super::build::cancel_build(world);
+                    ui.close();
+                }
+                ui.separator();
+                let has_output = world.resource::<super::build::BuildPanel>().has_output();
+                if menu_item(ui, "Reveal Output", None, has_output).clicked() {
+                    super::build::reveal_last_output(world);
+                    ui.close();
+                }
+            });
+
             ui.menu_button("View", |ui| {
                 if menu_item(ui, "Reset Layout", None, true).clicked() {
                     let layout = reset_and_save_layout(world);
diff --git a/crates/editor/src/ui/mod.rs b/crates/editor/src/ui/mod.rs
index f73ff50..290e48a 100644
--- a/crates/editor/src/ui/mod.rs
+++ b/crates/editor/src/ui/mod.rs
@@ -1,5 +1,8 @@
 mod actor_inspector;
+mod animation_inspector;
 mod asset_browser;
+mod audio_inspector;
+mod build;
 mod component_registry;
 mod diagnostics;
 mod dock_tabs;
@@ -13,6 +16,7 @@ mod layout;
 mod menu;
 mod play_controls;
 mod post_process_volume_ui;
+mod scene_tabs;
 pub mod selection_ops;
 mod status_bar;
 pub(crate) mod theme;
@@ -34,6 +38,7 @@ use crate::project_io::UserPreferences;
 use crate::selection::SelectedEntity;
 use crate::state::EditorMode;
 
+pub use build::BuildPanel;
 pub use diagnostics::{BrushDiagnosticsPanel, DiagnosticsPanel};
 pub use layout::LayoutSaveTimer;
 pub use viewport_chrome::ViewportUiState;
@@ -124,6 +129,7 @@ impl UiState {
     )]
     fn ui(&mut self, world: &mut World, ctx: &mut egui::Context, dt: f32) {
         apply_editor_theme(ctx);
+        let selected_before_ui = world.resource::<SelectedEntity>().0;
 
         let mode = *world.resource::<State<EditorMode>>().get();
         if self.last_mode_tab != Some(mode) {
@@ -156,7 +162,7 @@ impl UiState {
                 &mut self.panel_nodes,
             );
 
-            editor_toolbar_panel(world, root_ui);
+            editor_toolbar_panel(world, root_ui, &mut self.selected_entities);
             status_bar_ui(world, root_ui, &self.selected_entities, mode);
 
             let mut viewer = TabViewer {
@@ -202,6 +208,8 @@ impl UiState {
             .resource_mut::<crate::rendering_diagnostics::RenderingDiagnosticsPanel>()
             .open = rendering_open;
 
+        crate::session::session_resume_window(world, ctx);
+
         world.resource_scope(|world, mut panel: Mut<ProjectSettingsPanel>| {
             project_settings_window(world, ctx, &mut panel);
         });
@@ -210,11 +218,32 @@ impl UiState {
             world.resource_mut::<ViewportUiState>().shortcuts_open = true;
         }
 
+        let requested_selection = world.resource::<SelectedEntity>().0;
+        reconcile_operator_selection(
+            &mut self.selected_entities,
+            selected_before_ui,
+            requested_selection,
+        );
         let selected = self.selected_entities.as_slice().first().copied();
         world.resource_mut::<SelectedEntity>().0 = selected;
     }
 }
 
+fn reconcile_operator_selection(
+    selected_entities: &mut SelectedEntities,
+    selected_before_ui: Option<Entity>,
+    requested_selection: Option<Entity>,
+) {
+    let selected_after_ui = selected_entities.as_slice().first().copied();
+    if requested_selection == selected_before_ui || selected_after_ui != selected_before_ui {
+        return;
+    }
+    selected_entities.clear();
+    if let Some(entity) = requested_selection {
+        selected_entities.select_replace(entity);
+    }
+}
+
 fn tab_title(icon: egui_phosphor_icons::Icon, label: &str) -> egui::WidgetText {
     let mut job = egui::text::LayoutJob::default();
     job.append(
@@ -247,6 +276,7 @@ pub enum EditorTab {
     Inspector,
     Toolbar,
     AssetBrowser,
+    Build,
 }
 
 pub struct EditorUiPlugin;
@@ -256,12 +286,14 @@ impl Plugin for EditorUiPlugin {
         app.insert_resource(UiState::default_layout())
             .add_plugins(fonts::EditorFontsPlugin)
             .init_resource::<DiagnosticsPanel>()
+            .init_resource::<BuildPanel>()
             .init_resource::<BrushDiagnosticsPanel>()
             .init_resource::<component_registry::EditorComponentRegistry>()
             .init_resource::<crate::rendering_diagnostics::RenderingDiagnosticsPanel>()
             .init_resource::<asset_browser::AssetBrowserUiState>()
             .init_resource::<inspector::InspectorClipboard>()
             .init_resource::<inspector::InspectorPanelState>()
+            .init_resource::<animation_inspector::AnimationInspectorState>()
             .init_resource::<ViewportUiState>()
             .init_resource::<LayoutSaveTimer>()
             .add_systems(
@@ -275,7 +307,13 @@ impl Plugin for EditorUiPlugin {
                     .after(crate::project_io::load_user_preferences_on_startup),
             )
             .add_systems(EguiPrimaryContextPass, show_ui_system)
-            .add_systems(Update, hierarchy_state::tick_hierarchy_prefs_save);
+            .add_systems(
+                Update,
+                (
+                    hierarchy_state::tick_hierarchy_prefs_save,
+                    build::tick_build_job,
+                ),
+            );
     }
 }
 
@@ -360,6 +398,7 @@ impl egui_dock::TabViewer for TabViewer<'_> {
             EditorTab::AssetBrowser => {
                 asset_browser::asset_browser_ui(self.world, ui, self.selected_entities);
             }
+            EditorTab::Build => build::build_ui(self.world, ui),
         }
     }
 
@@ -370,6 +409,7 @@ impl egui_dock::TabViewer for TabViewer<'_> {
             EditorTab::Inspector => (icons::SLIDERS, "Inspector"),
             EditorTab::Toolbar => (icons::WRENCH, "Toolbar"),
             EditorTab::AssetBrowser => (icons::FOLDER, "Asset Browser"),
+            EditorTab::Build => (icons::HAMMER, "Build"),
         };
         tab_title(icon, label)
     }
@@ -381,3 +421,33 @@ impl egui_dock::TabViewer for TabViewer<'_> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn operator_selection_wins_when_ui_selection_did_not_change() {
+        let before = Entity::from_bits(1);
+        let spawned = Entity::from_bits(2);
+        let mut selected = SelectedEntities::default();
+        selected.select_replace(before);
+
+        reconcile_operator_selection(&mut selected, Some(before), Some(spawned));
+
+        assert_eq!(selected.as_slice(), &[spawned]);
+    }
+
+    #[test]
+    fn direct_ui_selection_wins_over_stale_operator_resource() {
+        let before = Entity::from_bits(1);
+        let clicked = Entity::from_bits(2);
+        let requested = Entity::from_bits(3);
+        let mut selected = SelectedEntities::default();
+        selected.select_replace(clicked);
+
+        reconcile_operator_selection(&mut selected, Some(before), Some(requested));
+
+        assert_eq!(selected.as_slice(), &[clicked]);
+    }
+}
diff --git a/crates/editor/src/ui/play_controls.rs b/crates/editor/src/ui/play_controls.rs
index 4015ea0..bc5d4a5 100644
--- a/crates/editor/src/ui/play_controls.rs
+++ b/crates/editor/src/ui/play_controls.rs
@@ -13,7 +13,7 @@ pub fn toggle_play_mode(world: &mut World) {
         if save_before && world.resource::<SceneIo>().dirty {
             let status = save_active_or_prompt_world(world);
             if status.contains("failed") || status.contains("cancelled") {
-                world.resource_mut::<SceneIo>().status = status;
+                world.resource_mut::<SceneIo>().set_status(status);
                 return;
             }
         }
diff --git a/crates/editor/src/ui/scene_tabs.rs b/crates/editor/src/ui/scene_tabs.rs
new file mode 100644
index 0000000..694baa2
--- /dev/null
+++ b/crates/editor/src/ui/scene_tabs.rs
@@ -0,0 +1,282 @@
+//! Top-level authored scene tabs and composition controls.
+
+use std::path::{Path, PathBuf};
+
+use bevy::prelude::*;
+use bevy_egui::egui;
+use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
+use egui_phosphor_icons::icons;
+use shared::{SceneComposition, SubsceneReference};
+
+use crate::scene_io::{ComposedSceneMember, SceneIo, SceneIoRequest};
+use crate::selection::SelectedEntity;
+
+use super::selection_ops::focus_editor_camera_on_selection;
+use super::theme::{BORDER, SELECTION, SELECTION_BG, TEXT, TEXT_DIM, TEXT_MUTED, WIDGET_BG};
+use super::widgets::phosphor_icon;
+
+pub fn scene_tabs_chrome(
+    world: &mut World,
+    ui: &mut egui::Ui,
+    selected: &mut SelectedEntities,
+    editing: bool,
+) {
+    let (tabs, active_tab) = {
+        let io = world.resource::<SceneIo>();
+        (io.tabs.clone(), io.active_tab)
+    };
+    let composition_editing = editing
+        && !world
+            .resource::<SceneIo>()
+            .active_path
+            .as_deref()
+            .is_some_and(crate::scene_io::is_prefab_document);
+    let composition_count = world.resource::<SceneComposition>().subscenes.len();
+    let mut request = None;
+    ui.spacing_mut().item_spacing.x = 3.0;
+    ui.menu_button(
+        super::tab_title(icons::STACK, &format!("Composition  {composition_count}")),
+        |ui| composition_menu(world, ui, selected, composition_editing),
+    )
+    .response
+    .on_hover_text(if composition_editing {
+        "Scene composition"
+    } else {
+        "Composition is unavailable for prefab documents"
+    });
+    ui.separator();
+    if ui
+        .add_enabled(
+            editing,
+            egui::Button::new(phosphor_icon(icons::PLUS, 13.0))
+                .frame(false)
+                .min_size(egui::vec2(22.0, 20.0)),
+        )
+        .on_hover_text("New scene tab")
+        .clicked()
+    {
+        request = Some(SceneIoRequest::New);
+    }
+
+    for (index, tab) in tabs.iter().enumerate().rev() {
+        if ui
+            .add_enabled(
+                editing,
+                egui::Button::new(phosphor_icon(icons::X, 11.0))
+                    .frame(false)
+                    .min_size(egui::vec2(18.0, 20.0)),
+            )
+            .on_hover_text("Close scene tab")
+            .clicked()
+        {
+            request = Some(SceneIoRequest::CloseTab(index));
+        }
+        let active = index == active_tab;
+        let label = if tab.dirty {
+            format!("{} *", tab.label())
+        } else {
+            tab.label()
+        };
+        let text = egui::RichText::new(label)
+            .color(if active { TEXT } else { TEXT_DIM })
+            .strong();
+        let response = ui.add_enabled(
+            editing,
+            egui::Button::new(text)
+                .fill(if active { SELECTION_BG } else { WIDGET_BG })
+                .stroke(egui::Stroke::new(
+                    1.0,
+                    if active { SELECTION } else { BORDER },
+                ))
+                .min_size(egui::vec2(128.0, 20.0)),
+        );
+        if response.clicked() && !active {
+            request = Some(SceneIoRequest::SwitchTab(index));
+        }
+        if response.hovered() {
+            let path = tab
+                .path
+                .as_deref()
+                .map(Path::display)
+                .map(|path| path.to_string())
+                .unwrap_or_else(|| "Unsaved scene".to_string());
+            response.on_hover_text(path);
+        }
+    }
+
+    if !editing {
+        ui.label(egui::RichText::new("Play mode").color(TEXT_MUTED));
+    }
+
+    if let Some(request) = request {
+        world.resource_mut::<SceneIo>().request = Some(request);
+    }
+}
+
+fn composition_menu(
+    world: &mut World,
+    ui: &mut egui::Ui,
+    selected: &mut SelectedEntities,
+    editing: bool,
+) {
+    ui.set_min_width(480.0);
+    let mut composition = world.resource::<SceneComposition>().clone();
+    ui.label(
+        egui::RichText::new(format!("Scene ID  {}", composition.scene_id))
+            .monospace()
+            .size(11.0)
+            .color(TEXT_MUTED),
+    );
+    ui.separator();
+
+    let mut changed = false;
+    let mut remove = None;
+    let mut focus = None;
+    if composition.subscenes.is_empty() {
+        ui.label(egui::RichText::new("No composed subscenes").color(TEXT_DIM));
+    }
+    for (index, reference) in composition.subscenes.iter_mut().enumerate() {
+        ui.horizontal(|ui| {
+            let file_name = Path::new(&reference.path)
+                .file_name()
+                .and_then(|name| name.to_str())
+                .unwrap_or(&reference.path);
+            ui.label(egui::RichText::new(file_name).strong().color(TEXT));
+            ui.label(
+                egui::RichText::new(&reference.path)
+                    .monospace()
+                    .size(10.0)
+                    .color(TEXT_MUTED),
+            );
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui
+                    .add_enabled(
+                        editing,
+                        egui::Button::new(phosphor_icon(icons::TRASH, 14.0)).frame(false),
+                    )
+                    .on_hover_text("Remove subscene reference")
+                    .clicked()
+                {
+                    remove = Some(index);
+                }
+                if ui
+                    .add_enabled(reference.visible, egui::Button::new("Focus"))
+                    .clicked()
+                {
+                    focus = Some(reference.id.clone());
+                    ui.close();
+                }
+                if ui
+                    .add_enabled(
+                        editing,
+                        egui::Checkbox::new(&mut reference.locked, "Locked"),
+                    )
+                    .changed()
+                {
+                    changed = true;
+                }
+                if ui
+                    .add_enabled(
+                        editing,
+                        egui::Checkbox::new(&mut reference.visible, "Loaded"),
+                    )
+                    .changed()
+                {
+                    changed = true;
+                }
+            });
+        });
+        ui.add_space(4.0);
+    }
+    if let Some(index) = remove {
+        composition.subscenes.remove(index);
+        changed = true;
+    }
+
+    ui.separator();
+    if ui
+        .add_enabled(editing, egui::Button::new("Add Subscene..."))
+        .clicked()
+    {
+        match choose_subscene(world, &composition) {
+            Ok(Some(reference)) => {
+                composition.subscenes.push(reference);
+                changed = true;
+            }
+            Ok(None) => {}
+            Err(error) => world
+                .resource_mut::<SceneIo>()
+                .set_status(format!("Add subscene failed: {error}")),
+        }
+    }
+
+    if changed {
+        crate::history::set_scene_composition_with_history(world, composition);
+    }
+    if let Some(reference_id) = focus {
+        focus_subscene(world, selected, &reference_id);
+    }
+}
+
+fn choose_subscene(
+    world: &World,
+    composition: &SceneComposition,
+) -> Result<Option<SubsceneReference>, String> {
+    let project_root = PathBuf::from(&world.resource::<crate::project_io::ProjectWorkspace>().root)
+        .canonicalize()
+        .map_err(|error| format!("could not resolve project root: {error}"))?;
+    let Some(path) = rfd::FileDialog::new()
+        .set_directory(project_root.join("assets/levels"))
+        .add_filter("Bevy scene", &["scn.ron", "ron"])
+        .pick_file()
+    else {
+        return Ok(None);
+    };
+    let path = path
+        .canonicalize()
+        .map_err(|error| format!("could not resolve {}: {error}", path.display()))?;
+    let relative = path.strip_prefix(&project_root).map_err(|_| {
+        format!(
+            "{} is outside project root {}",
+            path.display(),
+            project_root.display()
+        )
+    })?;
+    scene::validate_level_file(&path)?;
+    let relative = relative.to_string_lossy().replace('\\', "/");
+    if composition
+        .subscenes
+        .iter()
+        .any(|reference| reference.path == relative)
+    {
+        return Err(format!("{relative} is already composed"));
+    }
+    Ok(Some(SubsceneReference {
+        id: uuid::Uuid::new_v4().to_string(),
+        path: relative,
+        visible: true,
+        locked: true,
+    }))
+}
+
+fn focus_subscene(world: &mut World, selected: &mut SelectedEntities, reference_id: &str) {
+    let mut query = world.query::<(Entity, &ComposedSceneMember)>();
+    let entity = query.iter(world).find_map(|(entity, member)| {
+        (member.reference_id == reference_id
+            || member.reference_id.starts_with(&format!("{reference_id}/")))
+        .then_some(entity)
+    });
+    let Some(entity) = entity else {
+        world
+            .resource_mut::<SceneIo>()
+            .set_status("Subscene is not loaded or contains no authored actors");
+        return;
+    };
+    selected.clear();
+    selected.select_replace(entity);
+    world.resource_mut::<SelectedEntity>().0 = Some(entity);
+    focus_editor_camera_on_selection(world);
+    world
+        .resource_mut::<SceneIo>()
+        .set_status(format!("Focused composed subscene {reference_id}"));
+}
diff --git a/crates/editor/src/ui/selection_ops.rs b/crates/editor/src/ui/selection_ops.rs
index 408d4e9..8d9c8f8 100644
--- a/crates/editor/src/ui/selection_ops.rs
+++ b/crates/editor/src/ui/selection_ops.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
-use shared::LevelObject;
+use shared::{HydratedPrefabMember, LevelObject};
 
 use crate::camera::EditorCamera;
 use crate::history::{
@@ -11,6 +11,25 @@ use crate::history::{
 use crate::selection::SelectedEntity;
 use crate::ui::UiState;
 
+fn is_locked(world: &World, entity: Entity) -> bool {
+    world
+        .get_resource::<crate::ui::hierarchy_state::HierarchyPanelState>()
+        .is_some_and(|state| state.locked.contains(&entity))
+}
+
+pub fn is_linked_read_only(world: &World, entity: Entity) -> bool {
+    world.get::<HydratedPrefabMember>(entity).is_some()
+        || world
+            .get::<crate::scene_io::ComposedSceneMember>(entity)
+            .is_some()
+}
+
+pub fn is_mutable_level_object(world: &World, entity: Entity) -> bool {
+    is_level_object(world, entity)
+        && !is_locked(world, entity)
+        && !is_linked_read_only(world, entity)
+}
+
 pub fn focus_editor_camera_on_selection(world: &mut World) {
     let Some(entity) = world.resource::<SelectedEntity>().0 else {
         return;
@@ -53,12 +72,18 @@ pub fn is_level_object(world: &World, entity: Entity) -> bool {
 }
 
 pub fn delete_selection(world: &mut World, selected: &SelectedEntities) {
-    let entities = selected_level_entities(world, selected);
+    let entities: Vec<_> = selected_level_entities(world, selected)
+        .into_iter()
+        .filter(|entity| is_mutable_level_object(world, *entity))
+        .collect();
     delete_entities_with_history(world, &entities);
 }
 
 pub fn duplicate_selection(world: &mut World, selected: &SelectedEntities) {
-    let entities = selected_level_entities(world, selected);
+    let entities: Vec<_> = selected_level_entities(world, selected)
+        .into_iter()
+        .filter(|entity| is_mutable_level_object(world, *entity))
+        .collect();
     duplicate_entities_with_history(world, &entities);
 }
 
@@ -67,7 +92,7 @@ pub fn reset_selected_transforms(world: &mut World) {
         .resource::<UiState>()
         .selected_entities
         .iter()
-        .filter(|entity| is_level_object(world, *entity))
+        .filter(|entity| is_mutable_level_object(world, *entity))
         .filter_map(|entity| {
             world
                 .get::<Transform>(entity)
diff --git a/crates/editor/src/ui/status_bar.rs b/crates/editor/src/ui/status_bar.rs
index d7baf10..ae904db 100644
--- a/crates/editor/src/ui/status_bar.rs
+++ b/crates/editor/src/ui/status_bar.rs
@@ -3,13 +3,15 @@
 use bevy::prelude::*;
 use bevy_egui::egui;
 use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
+use egui_phosphor_icons::icons;
 
 use crate::history::EditorHistory;
 use crate::operators::ActiveOperator;
 use crate::scene_io::SceneIo;
 use crate::state::{EditorMode, PlayPaused};
 
-use super::theme::{status_bar_frame, TEXT};
+use super::theme::{status_bar_frame, ACCENT, SELECTION, SUCCESS, TEXT, TEXT_DIM, TEXT_MUTED};
+use super::widgets::phosphor_icon;
 
 pub fn status_bar_ui(
     world: &World,
@@ -18,10 +20,10 @@ pub fn status_bar_ui(
     mode: EditorMode,
 ) {
     egui::Panel::bottom("editor_status_bar")
-        .exact_size(24.0)
+        .exact_size(27.0)
         .frame(status_bar_frame())
         .show_inside(root_ui, |ui| {
-            ui.spacing_mut().item_spacing.x = 12.0;
+            ui.spacing_mut().item_spacing.x = 10.0;
             egui::containers::Sides::new()
                 .shrink_left()
                 .truncate()
@@ -29,23 +31,41 @@ pub fn status_bar_ui(
                     ui,
                     |ui| {
                         let status = primary_status_line(world);
+                        ui.label(
+                            egui::RichText::new("●")
+                                .color(if world.resource::<SceneIo>().dirty {
+                                    ACCENT
+                                } else {
+                                    SUCCESS
+                                })
+                                .small(),
+                        );
                         ui.add(
-                            egui::Label::new(egui::RichText::new(&status).color(TEXT)).truncate(),
+                            egui::Label::new(egui::RichText::new(&status).color(TEXT_DIM))
+                                .truncate(),
                         )
                         .on_hover_text(status);
                     },
                     |ui| {
-                        let mode_label = match mode {
-                            EditorMode::Editing => "Edit".to_string(),
+                        let (mode_icon, mode_label, mode_color) = match mode {
+                            EditorMode::Editing => (icons::PENCIL_SIMPLE, "EDIT", ACCENT),
                             EditorMode::Playing => {
                                 if world.resource::<PlayPaused>().0 {
-                                    "Play (paused)".to_string()
+                                    (icons::PAUSE, "PAUSED", ACCENT)
                                 } else {
-                                    "Play".to_string()
+                                    (icons::PLAY, "PLAYING", SUCCESS)
                                 }
                             }
                         };
-                        ui.label(egui::RichText::new(mode_label).color(TEXT));
+                        ui.label(phosphor_icon(mode_icon, 13.0).color(mode_color));
+                        ui.label(
+                            egui::RichText::new(mode_label)
+                                .color(mode_color)
+                                .strong()
+                                .small(),
+                        );
+
+                        ui.separator();
 
                         let count = selected.len();
                         let selection = match count {
@@ -53,11 +73,15 @@ pub fn status_bar_ui(
                             1 => "1 selected".to_string(),
                             _ => format!("{count} selected"),
                         };
-                        ui.label(egui::RichText::new(selection).color(TEXT));
+                        ui.label(egui::RichText::new(selection).color(if count == 0 {
+                            TEXT_MUTED
+                        } else {
+                            SELECTION
+                        }));
 
                         ui.label(
                             egui::RichText::new(world.resource::<EditorHistory>().status.clone())
-                                .color(TEXT),
+                                .color(TEXT_DIM),
                         );
 
                         if let Some(operator_label) = world.resource::<ActiveOperator>().label() {
@@ -76,7 +100,12 @@ pub fn status_bar_ui(
 
 fn scene_line(scene_io: &SceneIo) -> String {
     let dirty = if scene_io.dirty { " *" } else { "" };
-    format!("Scene: {}{dirty}", scene_io.active_path_label())
+    let recovery = if scene_io.recovery_snapshot.is_some() {
+        " [recovery]"
+    } else {
+        ""
+    };
+    format!("Scene: {}{dirty}{recovery}", scene_io.active_path_label())
 }
 
 fn primary_status_line(world: &World) -> String {
@@ -95,5 +124,8 @@ mod tests {
 
         scene_io.mark_dirty();
         assert!(scene_line(&scene_io).ends_with('*'));
+
+        scene_io.recovery_snapshot = Some("recovery.scn.ron".into());
+        assert!(scene_line(&scene_io).ends_with("[recovery]"));
     }
 }
diff --git a/crates/editor/src/ui/theme.rs b/crates/editor/src/ui/theme.rs
index bd6240d..10bd4ea 100644
--- a/crates/editor/src/ui/theme.rs
+++ b/crates/editor/src/ui/theme.rs
@@ -1,65 +1,103 @@
-//! Unity-inspired dark pro theme for editor egui + egui_dock chrome.
+//! Blacksite editor visual system for egui and egui_dock chrome.
 
 use bevy_egui::egui::{self, Color32, CornerRadius, FontId, Stroke, Visuals};
 use egui_dock::{Style as DockStyle, TabInteractionStyle, TabStyle};
 
-pub const PANEL_BG: Color32 = Color32::from_rgb(32, 33, 36);
-pub const PANEL_BG_DARK: Color32 = Color32::from_rgb(24, 25, 28);
-pub const WIDGET_BG: Color32 = Color32::from_rgb(42, 43, 47);
-pub const ELEVATED_BG: Color32 = Color32::from_rgb(55, 57, 63);
-pub const ACCENT: Color32 = Color32::from_rgb(56, 121, 184);
-pub const ACCENT_HOVER: Color32 = Color32::from_rgb(72, 143, 211);
-pub const SELECTION_BG: Color32 = Color32::from_rgb(46, 103, 158);
-pub const SELECTION_BG_MUTED: Color32 = Color32::from_rgb(43, 75, 108);
-pub const TEXT: Color32 = Color32::from_rgb(226, 229, 234);
-pub const TEXT_SELECTED: Color32 = Color32::from_rgb(250, 253, 255);
-pub const TEXT_DIM: Color32 = Color32::from_rgb(170, 176, 184);
-pub const TEXT_MUTED: Color32 = Color32::from_rgb(126, 133, 143);
-pub const BORDER: Color32 = Color32::from_rgb(69, 72, 78);
-pub const VIEWPORT_OVERLAY: Color32 = Color32::from_rgba_premultiplied(26, 27, 30, 220);
+pub const CANVAS_BG: Color32 = Color32::from_rgb(7, 8, 10);
+pub const PANEL_BG: Color32 = Color32::from_rgb(13, 15, 18);
+pub const PANEL_BG_DARK: Color32 = Color32::from_rgb(9, 11, 13);
+pub const WIDGET_BG: Color32 = Color32::from_rgb(21, 24, 28);
+pub const ELEVATED_BG: Color32 = Color32::from_rgb(31, 35, 40);
+pub const ACCENT: Color32 = Color32::from_rgb(229, 164, 51);
+pub const ACCENT_HOVER: Color32 = Color32::from_rgb(249, 193, 79);
+pub const SELECTION: Color32 = Color32::from_rgb(65, 198, 207);
+pub const SELECTION_SECONDARY: Color32 = Color32::from_rgb(84, 139, 155);
+pub const SELECTION_BG: Color32 = Color32::from_rgb(22, 72, 78);
+pub const SELECTION_BG_MUTED: Color32 = Color32::from_rgb(23, 48, 54);
+pub const TEXT: Color32 = Color32::from_rgb(220, 225, 229);
+pub const TEXT_SELECTED: Color32 = Color32::from_rgb(250, 251, 252);
+pub const TEXT_DIM: Color32 = Color32::from_rgb(155, 163, 171);
+pub const TEXT_MUTED: Color32 = Color32::from_rgb(96, 105, 114);
+pub const BORDER: Color32 = Color32::from_rgb(38, 43, 49);
+pub const BORDER_STRONG: Color32 = Color32::from_rgb(64, 71, 79);
+pub const SUCCESS: Color32 = Color32::from_rgb(84, 190, 127);
+pub const WARNING: Color32 = Color32::from_rgb(235, 180, 72);
+pub const ERROR: Color32 = Color32::from_rgb(226, 94, 94);
+pub const AXIS_X: Color32 = Color32::from_rgb(232, 83, 105);
+pub const AXIS_Y: Color32 = Color32::from_rgb(91, 201, 130);
+pub const AXIS_Z: Color32 = Color32::from_rgb(77, 147, 235);
+pub const VIEWPORT_OVERLAY: Color32 = Color32::from_rgba_premultiplied(7, 9, 11, 240);
 
 pub fn apply_editor_theme(ctx: &egui::Context) {
     let mut visuals = Visuals::dark();
     visuals.panel_fill = PANEL_BG;
     visuals.window_fill = WIDGET_BG;
-    visuals.extreme_bg_color = PANEL_BG_DARK;
-    visuals.faint_bg_color = Color32::from_rgb(38, 40, 44);
+    visuals.extreme_bg_color = CANVAS_BG;
+    visuals.faint_bg_color = Color32::from_rgb(17, 19, 22);
     visuals.code_bg_color = PANEL_BG_DARK;
-    visuals.text_edit_bg_color = Some(PANEL_BG_DARK);
+    visuals.text_edit_bg_color = Some(CANVAS_BG);
     visuals.weak_text_color = Some(TEXT_MUTED);
-    visuals.widgets.noninteractive.bg_fill = WIDGET_BG;
-    visuals.widgets.noninteractive.fg_stroke = Stroke::new(1.0, TEXT);
+    visuals.widgets.noninteractive.bg_fill = PANEL_BG;
+    visuals.widgets.noninteractive.bg_stroke = Stroke::new(1.0, BORDER);
+    visuals.widgets.noninteractive.fg_stroke = Stroke::new(1.0, TEXT_DIM);
     visuals.widgets.inactive.bg_fill = WIDGET_BG;
-    visuals.widgets.inactive.weak_bg_fill = Color32::from_rgb(47, 49, 54);
+    visuals.widgets.inactive.weak_bg_fill = Color32::from_rgb(24, 27, 31);
     visuals.widgets.inactive.bg_stroke = Stroke::new(1.0, BORDER);
     visuals.widgets.inactive.fg_stroke = Stroke::new(1.0, TEXT);
     visuals.widgets.hovered.bg_fill = ELEVATED_BG;
     visuals.widgets.hovered.weak_bg_fill = ELEVATED_BG;
-    visuals.widgets.hovered.bg_stroke = Stroke::new(1.0, ACCENT_HOVER);
+    visuals.widgets.hovered.bg_stroke = Stroke::new(1.0, BORDER_STRONG);
     visuals.widgets.hovered.fg_stroke = Stroke::new(1.0, TEXT_SELECTED);
-    visuals.widgets.active.bg_fill = SELECTION_BG;
-    visuals.widgets.active.weak_bg_fill = SELECTION_BG;
-    visuals.widgets.active.bg_stroke = Stroke::new(1.0, ACCENT_HOVER);
+    visuals.widgets.active.bg_fill = Color32::from_rgb(38, 42, 47);
+    visuals.widgets.active.weak_bg_fill = Color32::from_rgb(38, 42, 47);
+    visuals.widgets.active.bg_stroke = Stroke::new(1.0, ACCENT);
     visuals.widgets.active.fg_stroke = Stroke::new(1.0, TEXT_SELECTED);
     visuals.widgets.open.bg_fill = ELEVATED_BG;
     visuals.widgets.open.weak_bg_fill = ELEVATED_BG;
+    visuals.widgets.open.bg_stroke = Stroke::new(1.0, BORDER_STRONG);
     visuals.widgets.open.fg_stroke = Stroke::new(1.0, TEXT_SELECTED);
     visuals.selection.bg_fill = SELECTION_BG;
-    visuals.selection.stroke = Stroke::new(1.0, TEXT_SELECTED);
-    visuals.hyperlink_color = Color32::from_rgb(132, 186, 247);
-    visuals.warn_fg_color = Color32::from_rgb(255, 200, 80);
-    visuals.error_fg_color = Color32::from_rgb(255, 100, 100);
+    visuals.selection.stroke = Stroke::new(1.0, SELECTION);
+    visuals.hyperlink_color = SELECTION;
+    visuals.warn_fg_color = WARNING;
+    visuals.error_fg_color = ERROR;
     visuals.window_stroke = Stroke::new(1.0, BORDER);
     visuals.window_corner_radius = CornerRadius::same(4);
+    visuals.menu_corner_radius = CornerRadius::same(3);
+    visuals.window_shadow = egui::epaint::Shadow {
+        offset: [0, 8],
+        blur: 28,
+        spread: 2,
+        color: Color32::from_black_alpha(190),
+    };
+    visuals.popup_shadow = egui::epaint::Shadow {
+        offset: [0, 5],
+        blur: 18,
+        spread: 1,
+        color: Color32::from_black_alpha(205),
+    };
+    visuals.button_frame = true;
+    visuals.collapsing_header_frame = false;
+    visuals.indent_has_left_vline = true;
+    visuals.striped = true;
+    visuals.slider_trailing_fill = true;
+    visuals.interact_cursor = Some(egui::CursorIcon::PointingHand);
 
     let mut style = (*ctx.global_style()).clone();
     style.visuals = visuals;
-    style.spacing.item_spacing = egui::vec2(8.0, 6.0);
-    style.spacing.button_padding = egui::vec2(8.0, 4.0);
-    style.spacing.indent = 16.0;
+    style.spacing.item_spacing = egui::vec2(8.0, 7.0);
+    style.spacing.button_padding = egui::vec2(10.0, 5.0);
+    style.spacing.interact_size = egui::vec2(40.0, 28.0);
+    style.spacing.window_margin = egui::Margin::same(10);
+    style.spacing.menu_margin = egui::Margin::same(8);
+    style.spacing.indent = 17.0;
+    style.interaction.tooltip_delay = 0.32;
+    style.interaction.tooltip_grace_time = 0.18;
+    style.animation_time = 0.12;
+    style.compact_menu_style = true;
     style.text_styles.insert(
         egui::TextStyle::Body,
-        FontId::new(13.0, egui::FontFamily::Proportional),
+        FontId::new(14.0, egui::FontFamily::Proportional),
     );
     style.text_styles.insert(
         egui::TextStyle::Button,
@@ -67,42 +105,49 @@ pub fn apply_editor_theme(ctx: &egui::Context) {
     );
     style.text_styles.insert(
         egui::TextStyle::Heading,
-        FontId::new(15.0, egui::FontFamily::Proportional),
+        FontId::new(16.0, egui::FontFamily::Proportional),
+    );
+    style.text_styles.insert(
+        egui::TextStyle::Small,
+        FontId::new(12.0, egui::FontFamily::Proportional),
     );
     ctx.set_global_style(style);
 }
 
 pub fn editor_dock_style(ctx: &egui::Context) -> DockStyle {
     let mut style = DockStyle::from_egui(ctx.global_style().as_ref());
-    style.dock_area_padding = Some(egui::Margin::same(2));
+    style.dock_area_padding = Some(egui::Margin::same(1));
     style.main_surface_border_stroke = Stroke::new(1.0, BORDER);
+    style.main_surface_border_rounding = CornerRadius::ZERO;
     style.separator.width = 2.0;
+    style.separator.extra_interact_width = 5.0;
     style.separator.color_idle = BORDER;
-    style.separator.color_hovered = ELEVATED_BG;
+    style.separator.color_hovered = BORDER_STRONG;
     style.separator.color_dragged = ACCENT_HOVER;
 
     style.tab_bar.bg_fill = PANEL_BG_DARK;
-    style.tab_bar.height = 26.0;
-    style.tab_bar.hline_color = BORDER;
+    style.tab_bar.height = 30.0;
+    style.tab_bar.inner_margin = egui::Margin::symmetric(2, 1);
+    style.tab_bar.hline_color = ACCENT;
     style.tab_bar.corner_radius = CornerRadius::ZERO;
 
     let active = TabInteractionStyle {
-        outline_color: BORDER,
+        outline_color: ACCENT,
         bg_fill: PANEL_BG,
-        text_color: TEXT,
-        corner_radius: CornerRadius::same(3),
+        text_color: TEXT_SELECTED,
+        corner_radius: CornerRadius::same(1),
     };
     let inactive = TabInteractionStyle {
         outline_color: Color32::TRANSPARENT,
-        bg_fill: WIDGET_BG,
+        bg_fill: Color32::TRANSPARENT,
         text_color: TEXT_DIM,
-        corner_radius: CornerRadius::same(3),
+        corner_radius: CornerRadius::same(1),
     };
     let hovered = TabInteractionStyle {
-        outline_color: BORDER,
+        outline_color: BORDER_STRONG,
         bg_fill: ELEVATED_BG,
         text_color: TEXT,
-        corner_radius: CornerRadius::same(3),
+        corner_radius: CornerRadius::same(1),
     };
 
     style.tab = TabStyle {
@@ -113,8 +158,16 @@ pub fn editor_dock_style(ctx: &egui::Context) -> DockStyle {
         inactive_with_kb_focus: inactive.clone(),
         active_with_kb_focus: active.clone(),
         focused_with_kb_focus: active,
+        hline_below_active_tab_name: true,
+        spacing: 2.0,
         ..style.tab
     };
+    style.tab.tab_body.inner_margin = egui::Margin::same(4);
+    style.tab.tab_body.bg_fill = PANEL_BG;
+    style.tab.tab_body.stroke = Stroke::new(1.0, BORDER);
+    style.overlay.selection_color = SELECTION_BG;
+    style.overlay.button_color = SELECTION;
+    style.overlay.button_border_stroke = Stroke::new(1.0, SELECTION);
 
     style
 }
@@ -125,14 +178,45 @@ pub fn panel_heading(text: &str) -> egui::RichText {
 
 pub fn status_bar_frame() -> egui::Frame {
     egui::Frame::new()
-        .fill(Color32::from_rgb(0, 122, 204))
-        .inner_margin(egui::Margin::symmetric(8, 2))
+        .fill(PANEL_BG_DARK)
+        .inner_margin(egui::Margin::symmetric(10, 3))
+        .stroke(Stroke::new(1.0, BORDER))
+}
+
+pub fn brand_mark_frame() -> egui::Frame {
+    egui::Frame::new()
+        .fill(CANVAS_BG)
+        .corner_radius(CornerRadius::same(2))
+        .inner_margin(egui::Margin::symmetric(8, 4))
+        .stroke(Stroke::new(1.0, BORDER_STRONG))
 }
 
 pub fn viewport_toolbar_frame() -> egui::Frame {
     egui::Frame::new()
         .fill(VIEWPORT_OVERLAY)
-        .corner_radius(CornerRadius::same(4))
-        .inner_margin(egui::Margin::same(4))
+        .corner_radius(CornerRadius::same(3))
+        .inner_margin(egui::Margin::same(5))
+        .stroke(Stroke::new(1.0, BORDER_STRONG))
+        .shadow(egui::epaint::Shadow {
+            offset: [0, 3],
+            blur: 12,
+            spread: 0,
+            color: Color32::from_black_alpha(110),
+        })
+}
+
+pub fn overlay_chip_frame() -> egui::Frame {
+    egui::Frame::new()
+        .fill(VIEWPORT_OVERLAY)
+        .corner_radius(CornerRadius::same(3))
+        .inner_margin(egui::Margin::symmetric(8, 5))
+        .stroke(Stroke::new(1.0, BORDER_STRONG))
+}
+
+pub fn toolbar_group_frame() -> egui::Frame {
+    egui::Frame::new()
+        .fill(PANEL_BG_DARK)
+        .corner_radius(CornerRadius::same(3))
+        .inner_margin(egui::Margin::symmetric(5, 3))
         .stroke(Stroke::new(1.0, BORDER))
 }
diff --git a/crates/editor/src/ui/toolbar.rs b/crates/editor/src/ui/toolbar.rs
index 9474fe6..5b530c3 100644
--- a/crates/editor/src/ui/toolbar.rs
+++ b/crates/editor/src/ui/toolbar.rs
@@ -2,6 +2,7 @@
 
 use bevy::prelude::*;
 use bevy_egui::egui;
+use bevy_inspector_egui::bevy_inspector::hierarchy::SelectedEntities;
 use egui_phosphor_icons::icons;
 
 use crate::history::spawn_with_history;
@@ -15,35 +16,46 @@ use shared::PrimitiveShape;
 use super::helpers::{
     light_snapshot, primitive_snapshot, toggle_play_mode, toggle_play_paused, toggle_possession,
 };
-use super::widgets::{icon_button, panel_toolbar_row, toolbar_separator, transport_button_large};
+use super::theme::{brand_mark_frame, toolbar_group_frame, ACCENT, TEXT, TEXT_MUTED};
+use super::widgets::{
+    icon_button, panel_toolbar_row, phosphor_icon, toolbar_separator, transport_button_large,
+};
 
 /// Toolbar strip height (menu bar is separate).
-const TOOLBAR_HEIGHT: f32 = 56.0;
-const TRANSPORT_WIDTH: f32 = 152.0;
-const TRANSPORT_SLOT_STEP: f32 = 54.0;
+const TOOLBAR_HEIGHT: f32 = 50.0;
+const TRANSPORT_WIDTH: f32 = 150.0;
+const TRANSPORT_SLOT_STEP: f32 = 50.0;
 
-pub fn editor_toolbar_panel(world: &mut World, root_ui: &mut egui::Ui) {
+pub fn editor_toolbar_panel(
+    world: &mut World,
+    root_ui: &mut egui::Ui,
+    selected: &mut SelectedEntities,
+) {
     egui::Panel::top("editor_toolbar")
         .exact_size(TOOLBAR_HEIGHT)
         .show_inside(root_ui, |ui| {
-            toolbar_ui(world, ui);
+            toolbar_ui(world, ui, selected);
         });
 }
 
-pub fn toolbar_ui(world: &mut World, ui: &mut egui::Ui) {
+pub fn toolbar_ui(world: &mut World, ui: &mut egui::Ui, selected: &mut SelectedEntities) {
     let (toolbar_rect, _) = ui.allocate_exact_size(
-        egui::vec2(ui.available_width(), TOOLBAR_HEIGHT - 4.0),
+        egui::vec2(ui.available_width(), TOOLBAR_HEIGHT - 2.0),
         egui::Sense::hover(),
     );
 
     let center_y = toolbar_rect.center().y;
     let left_rect = egui::Rect::from_min_max(
-        egui::pos2(toolbar_rect.left() + 8.0, center_y - 18.0),
-        egui::pos2(toolbar_rect.right(), center_y + 18.0),
+        egui::pos2(toolbar_rect.left() + 8.0, center_y - 20.0),
+        egui::pos2(toolbar_rect.right(), center_y + 20.0),
     );
     let transport_rect = egui::Rect::from_center_size(
         egui::pos2(toolbar_rect.center().x, center_y),
-        egui::vec2(TRANSPORT_WIDTH, 44.0),
+        egui::vec2(TRANSPORT_WIDTH, 46.0),
+    );
+    let right_rect = egui::Rect::from_min_max(
+        egui::pos2(transport_rect.right() + 18.0, center_y - 20.0),
+        egui::pos2(toolbar_rect.right() - 8.0, center_y + 20.0),
     );
 
     let mut left_ui = ui.new_child(
@@ -62,42 +74,89 @@ pub fn toolbar_ui(world: &mut World, ui: &mut egui::Ui) {
             .layout(egui::Layout::left_to_right(egui::Align::Center)),
     );
     transport_ui.spacing_mut().item_spacing.x = 10.0;
-    transport_controls(world, &mut transport_ui);
+    toolbar_group_frame().show(&mut transport_ui, |ui| {
+        transport_controls(world, ui);
+    });
+
+    let mut right_ui = ui.new_child(
+        egui::UiBuilder::new()
+            .id_salt("toolbar_scene_documents")
+            .max_rect(right_rect)
+            .layout(egui::Layout::right_to_left(egui::Align::Center)),
+    );
+    let editing = *world.resource::<State<EditorMode>>().get() == EditorMode::Editing;
+    super::scene_tabs::scene_tabs_chrome(world, &mut right_ui, selected, editing);
+
+    ui.painter().line_segment(
+        [toolbar_rect.left_bottom(), toolbar_rect.right_bottom()],
+        egui::Stroke::new(1.0, super::theme::BORDER),
+    );
+    ui.painter().line_segment(
+        [
+            toolbar_rect.left_bottom() + egui::vec2(8.0, 0.0),
+            toolbar_rect.left_bottom() + egui::vec2(134.0, 0.0),
+        ],
+        egui::Stroke::new(2.0, ACCENT),
+    );
 }
 
 fn left_toolbar(world: &mut World, ui: &mut egui::Ui) {
-    panel_toolbar_row(ui, |ui| {
-        if icon_button(ui, icons::CUBE, "Spawn cube").clicked() {
-            spawn_primitive_at_camera(world, PrimitiveShape::Box, "Cube");
-        }
-        if icon_button(ui, icons::MOUNTAINS, "Spawn ramp").clicked() {
-            spawn_primitive_at_camera(world, PrimitiveShape::Ramp, "Ramp");
-        }
-        if icon_button(ui, icons::SPHERE, "Spawn sphere").clicked() {
-            spawn_primitive_at_camera(world, PrimitiveShape::Sphere, "Sphere");
-        }
-        if icon_button(ui, icons::LIGHTBULB, "Spawn point light").clicked() {
-            let pos = camera_ground_spawn(world);
-            spawn_with_history(world, light_snapshot("Point Light", pos));
-        }
-        if icon_button(ui, icons::PENCIL_SIMPLE_LINE, "Draw brush (B)").clicked() {
-            start_draw_brush_tool(world);
-        }
+    brand_mark_frame().show(ui, |ui| {
+        ui.set_min_width(118.0);
+        ui.set_min_height(30.0);
+        ui.horizontal(|ui| {
+            ui.label(phosphor_icon(icons::CROSSHAIR, 19.0).color(ACCENT));
+            ui.vertical(|ui| {
+                ui.spacing_mut().item_spacing.y = 0.0;
+                ui.label(
+                    egui::RichText::new("BLACKSITE")
+                        .size(11.0)
+                        .strong()
+                        .color(TEXT),
+                );
+                ui.label(
+                    egui::RichText::new("EDITOR // DEV")
+                        .size(9.0)
+                        .color(TEXT_MUTED),
+                );
+            });
+        });
+    });
 
-        toolbar_separator(ui);
+    toolbar_group_frame().show(ui, |ui| {
+        panel_toolbar_row(ui, |ui| {
+            if icon_button(ui, icons::CUBE, "Spawn cube").clicked() {
+                spawn_primitive_at_camera(world, PrimitiveShape::Box, "Cube");
+            }
+            if icon_button(ui, icons::MOUNTAINS, "Spawn ramp").clicked() {
+                spawn_primitive_at_camera(world, PrimitiveShape::Ramp, "Ramp");
+            }
+            if icon_button(ui, icons::SPHERE, "Spawn sphere").clicked() {
+                spawn_primitive_at_camera(world, PrimitiveShape::Sphere, "Sphere");
+            }
+            if icon_button(ui, icons::LIGHTBULB, "Spawn point light").clicked() {
+                let pos = camera_ground_spawn(world);
+                spawn_with_history(world, light_snapshot("Point Light", pos));
+            }
+            if icon_button(ui, icons::PENCIL_SIMPLE_LINE, "Draw brush (B)").clicked() {
+                start_draw_brush_tool(world);
+            }
 
-        if icon_button(ui, icons::FILE, "New scene").clicked() {
-            world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::New);
-        }
-        if icon_button(ui, icons::FOLDER_OPEN, "Open scene").clicked() {
-            world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::Open);
-        }
-        if icon_button(ui, icons::FLOPPY_DISK, "Save scene").clicked() {
-            world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::Save);
-        }
-        if icon_button(ui, icons::COPY, "Save scene as").clicked() {
-            world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::SaveAs);
-        }
+            toolbar_separator(ui);
+
+            if icon_button(ui, icons::FILE, "New scene").clicked() {
+                world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::New);
+            }
+            if icon_button(ui, icons::FOLDER_OPEN, "Open scene").clicked() {
+                world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::Open);
+            }
+            if icon_button(ui, icons::FLOPPY_DISK, "Save scene").clicked() {
+                world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::Save);
+            }
+            if icon_button(ui, icons::COPY, "Save scene as").clicked() {
+                world.resource_mut::<SceneIo>().request = Some(SceneIoRequest::SaveAs);
+            }
+        });
     });
 }
 
@@ -106,11 +165,9 @@ fn transport_controls(world: &mut World, ui: &mut egui::Ui) {
     match mode {
         EditorMode::Editing => {
             ui.add_space(TRANSPORT_SLOT_STEP);
-            let play_clicked = ui
-                .push_id("transport_center", |ui| {
-                    transport_button_large(ui, icons::PLAY, "Play (F5)", true).clicked()
-                })
-                .inner;
+            let play_clicked =
+                transport_button_large(ui, "transport_center", icons::PLAY, "Play (F5)", true)
+                    .clicked();
             if play_clicked {
                 toggle_play_mode(world);
             }
@@ -123,20 +180,20 @@ fn transport_controls(world: &mut World, ui: &mut egui::Ui) {
             } else {
                 "Pause simulation (F6)"
             };
-            let pause_clicked = ui
-                .push_id("transport_left", |ui| {
-                    transport_button_large(ui, pause_icon, pause_tip, false).clicked()
-                })
-                .inner;
+            let pause_clicked =
+                transport_button_large(ui, "transport_left", pause_icon, pause_tip, false)
+                    .clicked();
             if pause_clicked {
                 toggle_play_paused(world);
             }
-            let stop_clicked = ui
-                .push_id("transport_center", |ui| {
-                    transport_button_large(ui, icons::STOP, "Stop and return to Edit (F5)", false)
-                        .clicked()
-                })
-                .inner;
+            let stop_clicked = transport_button_large(
+                ui,
+                "transport_center",
+                icons::STOP,
+                "Stop and return to Edit (F5)",
+                false,
+            )
+            .clicked();
             if stop_clicked {
                 toggle_play_mode(world);
             }
@@ -146,11 +203,9 @@ fn transport_controls(world: &mut World, ui: &mut egui::Ui) {
                 PlayPossession::Possessed => (icons::SIGN_OUT, "Eject from player (F8)"),
                 PlayPossession::Ejected => (icons::USER, "Possess player (F8)"),
             };
-            let possession_clicked = ui
-                .push_id("transport_right", |ui| {
-                    transport_button_large(ui, eject_icon, eject_tip, false).clicked()
-                })
-                .inner;
+            let possession_clicked =
+                transport_button_large(ui, "transport_right", eject_icon, eject_tip, false)
+                    .clicked();
             if possession_clicked {
                 toggle_possession(world);
             }
diff --git a/crates/editor/src/ui/viewport_chrome.rs b/crates/editor/src/ui/viewport_chrome.rs
index 9fcccb2..cab22fc 100644
--- a/crates/editor/src/ui/viewport_chrome.rs
+++ b/crates/editor/src/ui/viewport_chrome.rs
@@ -7,12 +7,15 @@ use egui_phosphor_icons::icons;
 use transform_gizmo_bevy::prelude::GizmoOptions;
 
 use crate::assets::operators::{
-    apply_material_operator, apply_texture_operator, place_asset_operator, place_subasset_operator,
+    apply_material_operator, apply_texture_operator, assign_animation_clip_operator,
+    assign_audio_clip_operator, place_asset_operator, place_subasset_operator,
 };
+use crate::assets::thumbnails::kind_icon;
 use crate::assets::{AssetSelection, AssetSubAssetKind, EditorAssets};
+use crate::camera::EditorCamera;
 use crate::gizmos::{EditorGizmoMode, EditorGizmoSpace};
 use crate::render_target::ViewportRenderTarget;
-use crate::selection::ViewportClick;
+use crate::selection::{ViewportClick, ViewportPickStack};
 use crate::state::PlayPossession;
 use crate::viewport::actor_icons::ActorIconSettings;
 use crate::viewport::brush_edit::{BrushEditMode, BrushElementSelection};
@@ -25,8 +28,13 @@ use crate::viewport::{
 use super::helpers::{
     focus_editor_camera_on_selection, viewport_recall_bookmark, viewport_save_bookmark,
 };
-use super::theme::viewport_toolbar_frame;
-use super::widgets::{icon_button_small, panel_toolbar_row, tool_button};
+use super::theme::{
+    overlay_chip_frame, viewport_toolbar_frame, ACCENT, ACCENT_HOVER, AXIS_X, AXIS_Y, AXIS_Z,
+    BORDER, BORDER_STRONG, ELEVATED_BG, SELECTION, SUCCESS, TEXT, TEXT_DIM, TEXT_MUTED, WARNING,
+};
+use super::widgets::{
+    icon_button_small, panel_toolbar_row, phosphor_icon, tool_button, tool_button_accent,
+};
 
 #[derive(Resource, Default)]
 pub struct ViewportUiState {
@@ -97,6 +105,19 @@ pub fn viewport_tab_ui(
             egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)),
             egui::Color32::WHITE,
         );
+        painter.rect_stroke(
+            rect,
+            0.0,
+            egui::Stroke::new(
+                1.0,
+                if response.hovered() {
+                    BORDER_STRONG
+                } else {
+                    BORDER
+                },
+            ),
+            egui::StrokeKind::Inside,
+        );
     } else {
         ui.allocate_rect(rect, egui::Sense::hover());
         ui.scope_builder(egui::UiBuilder::new().max_rect(rect), |ui| {
@@ -114,35 +135,49 @@ pub fn viewport_tab_ui(
     }
 
     scene_view_overlay_toolbar(world, ui.ctx(), rect);
+    scene_view_selection_hud(world, ui.ctx(), rect, selected_entities);
     scene_view_brush_draw_hints(world, ui.ctx(), rect);
-    scene_view_mode_badge(world, ui.ctx(), rect);
+    scene_view_render_badge(world, ui.ctx(), rect);
     scene_view_brush_mode_badge(world, ui.ctx(), rect);
-    scene_view_gi_badge(world, ui.ctx(), rect);
     scene_view_volume_hud(world, ui.ctx(), rect);
+    scene_view_orientation_widget(world, ui.ctx(), rect);
     viewport_asset_drop_ui(world, ui, rect, selected_entities);
 }
 
-fn scene_view_mode_badge(world: &World, ctx: &egui::Context, scene_rect: egui::Rect) {
+fn scene_view_render_badge(world: &World, ctx: &egui::Context, scene_rect: egui::Rect) {
     let Some(mode) = world.get_resource::<EditorViewportMode>() else {
         return;
     };
     let mode = *mode;
     let (label, color) = match mode {
-        EditorViewportMode::Lit => ("Lit", egui::Color32::from_rgb(120, 200, 120)),
-        EditorViewportMode::Unlit => ("Unlit", egui::Color32::from_rgb(200, 200, 120)),
-        EditorViewportMode::Collider => ("Collider", egui::Color32::from_rgb(220, 140, 80)),
+        EditorViewportMode::Lit => ("Lit", SUCCESS),
+        EditorViewportMode::Unlit => ("Unlit", WARNING),
+        EditorViewportMode::Collider => ("Collider", WARNING),
     };
 
-    egui::Area::new(egui::Id::new("scene_view_mode_badge"))
-        .fixed_pos(scene_rect.right_bottom() + egui::vec2(-72.0, -22.0))
+    let profile = world.get_resource::<settings::ActiveCameraRenderProfile>();
+    let (gi_label, gi_color) = match profile.map(|profile| profile.gi_path) {
+        Some(settings::GiPath::SolariDeferred) => ("Solari", ACCENT),
+        _ => ("Forward", SELECTION),
+    };
+
+    egui::Area::new(egui::Id::new("scene_view_render_badge"))
+        .fixed_pos(scene_rect.right_bottom() + egui::vec2(-10.0, -10.0))
+        .pivot(egui::Align2::RIGHT_BOTTOM)
         .interactable(false)
         .show(ctx, |ui| {
-            egui::Frame::NONE
-                .fill(egui::Color32::from_black_alpha(160))
-                .inner_margin(egui::Margin::symmetric(8, 4))
-                .show(ui, |ui| {
-                    ui.colored_label(color, label);
+            overlay_chip_frame().show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label(egui::RichText::new(label).color(color).strong().small());
+                    ui.label(egui::RichText::new("/").color(TEXT_MUTED).small());
+                    ui.label(
+                        egui::RichText::new(gi_label)
+                            .color(gi_color)
+                            .strong()
+                            .small(),
+                    );
                 });
+            });
         });
 
     if mode == EditorViewportMode::Collider {
@@ -150,10 +185,13 @@ fn scene_view_mode_badge(world: &World, ctx: &egui::Context, scene_rect: egui::R
             .fixed_pos(scene_rect.left_bottom() + egui::vec2(8.0, -28.0))
             .interactable(false)
             .show(ctx, |ui| {
-                ui.colored_label(
-                    egui::Color32::from_rgb(255, 180, 100),
-                    "Meshes hidden - switch to Lit (sun icon) for shading",
-                );
+                overlay_chip_frame().show(ui, |ui| {
+                    ui.label(
+                        egui::RichText::new("Collider view / meshes hidden")
+                            .color(WARNING)
+                            .small(),
+                    );
+                });
             });
     }
 }
@@ -173,51 +211,39 @@ fn scene_view_brush_mode_badge(world: &World, ctx: &egui::Context, scene_rect: e
         .fixed_pos(scene_rect.left_top() + egui::vec2(8.0, 52.0))
         .interactable(false)
         .show(ctx, |ui| {
-            egui::Frame::new()
-                .fill(egui::Color32::from_rgba_unmultiplied(20, 18, 28, 230))
-                .stroke(egui::Stroke::new(
-                    1.0,
-                    egui::Color32::from_rgba_unmultiplied(210, 140, 255, 210),
-                ))
-                .corner_radius(egui::CornerRadius::same(4))
-                .inner_margin(egui::Margin::symmetric(8, 6))
-                .show(ui, |ui| {
-                    ui.horizontal(|ui| {
-                        ui.label(
-                            egui::RichText::new(format!("Brush {}", mode.label()))
-                                .color(egui::Color32::from_rgb(230, 190, 255))
-                                .strong(),
-                        );
-                        ui.label(
-                            egui::RichText::new(format!("{selected_count} selected"))
-                                .color(egui::Color32::from_rgb(205, 200, 215))
-                                .small(),
-                        );
-                        ui.label(
-                            egui::RichText::new("Element gizmo")
-                                .color(egui::Color32::from_rgb(255, 190, 120))
-                                .small(),
-                        );
-                    });
-                    ui.add_space(4.0);
-                    ui.horizontal_wrapped(|ui| {
-                        match mode {
-                            BrushEditMode::Vertex => key_hint(ui, "LMB", "Select vertex"),
-                            BrushEditMode::Edge => key_hint(ui, "LMB", "Select edge"),
-                            BrushEditMode::Face => key_hint(ui, "LMB", "Select face"),
-                            BrushEditMode::Clip => key_hint(ui, "LMB", "Select face"),
-                            BrushEditMode::Object => {}
-                        }
-                        if !matches!(mode, BrushEditMode::Clip) {
-                            key_hint(ui, "W/E/R", "Move/rotate/scale");
-                        }
-                        if matches!(mode, BrushEditMode::Clip) {
-                            key_hint(ui, "Enter", "Clip");
-                        }
-                        key_hint(ui, "Shift+LMB", "Multi");
-                        key_hint(ui, "Esc", "Object");
-                    });
+            overlay_chip_frame().show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label(
+                        egui::RichText::new(format!("Brush {}", mode.label()))
+                            .color(ACCENT)
+                            .strong(),
+                    );
+                    ui.label(
+                        egui::RichText::new(format!("{selected_count} selected"))
+                            .color(SELECTION)
+                            .small(),
+                    );
+                    ui.label(egui::RichText::new("Element gizmo").color(SUCCESS).small());
                 });
+                ui.add_space(4.0);
+                ui.horizontal_wrapped(|ui| {
+                    match mode {
+                        BrushEditMode::Vertex => key_hint(ui, "LMB", "Select vertex"),
+                        BrushEditMode::Edge => key_hint(ui, "LMB", "Select edge"),
+                        BrushEditMode::Face => key_hint(ui, "LMB", "Select face"),
+                        BrushEditMode::Clip => key_hint(ui, "LMB", "Select face"),
+                        BrushEditMode::Object => {}
+                    }
+                    if !matches!(mode, BrushEditMode::Clip) {
+                        key_hint(ui, "W/E/R", "Move/rotate/scale");
+                    }
+                    if matches!(mode, BrushEditMode::Clip) {
+                        key_hint(ui, "Enter", "Clip");
+                    }
+                    key_hint(ui, "Shift+LMB", "Multi");
+                    key_hint(ui, "Esc", "Object");
+                });
+            });
         });
 }
 
@@ -237,51 +263,35 @@ fn scene_view_brush_draw_hints(world: &World, ctx: &egui::Context, scene_rect: e
         .fixed_pos(scene_rect.left_top() + egui::vec2(8.0, 52.0))
         .interactable(false)
         .show(ctx, |ui| {
-            egui::Frame::new()
-                .fill(egui::Color32::from_rgba_unmultiplied(18, 22, 26, 220))
-                .stroke(egui::Stroke::new(
-                    1.0,
-                    egui::Color32::from_rgba_unmultiplied(95, 150, 190, 180),
-                ))
-                .corner_radius(egui::CornerRadius::same(4))
-                .inner_margin(egui::Margin::symmetric(8, 6))
-                .show(ui, |ui| {
-                    ui.horizontal(|ui| {
-                        ui.label(
-                            egui::RichText::new("Draw Brush")
-                                .color(egui::Color32::from_rgb(170, 220, 255))
-                                .strong(),
-                        );
-                        ui.label(
-                            egui::RichText::new(format!("{} pts", tool.vertices.len()))
-                                .color(egui::Color32::from_rgb(190, 200, 205))
-                                .small(),
-                        );
-                        ui.label(
-                            egui::RichText::new(hint)
-                                .color(egui::Color32::from_rgb(150, 220, 170))
-                                .small(),
-                        );
-                    });
-                    ui.add_space(4.0);
-                    ui.horizontal_wrapped(|ui| match tool.phase {
-                        BrushToolPhase::Outline => {
-                            key_hint(ui, "LMB", "Point");
-                            key_hint(ui, "Enter", "Height");
-                            key_hint(ui, "Backspace", "Remove");
-                            key_hint(ui, "Esc", "Cancel");
-                            key_hint(ui, "RMB", "Cancel");
-                        }
-                        BrushToolPhase::Height => {
-                            key_hint(ui, "Mouse Up/Down", "Height");
-                            key_hint(ui, "Enter", "Create");
-                            key_hint(ui, "LMB", "Create");
-                            key_hint(ui, "Backspace", "Outline");
-                            key_hint(ui, "Esc", "Cancel");
-                            key_hint(ui, "RMB", "Cancel");
-                        }
-                    });
+            overlay_chip_frame().show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label(egui::RichText::new("Draw Brush").color(SELECTION).strong());
+                    ui.label(
+                        egui::RichText::new(format!("{} pts", tool.vertices.len()))
+                            .color(TEXT_DIM)
+                            .small(),
+                    );
+                    ui.label(egui::RichText::new(hint).color(SUCCESS).small());
                 });
+                ui.add_space(4.0);
+                ui.horizontal_wrapped(|ui| match tool.phase {
+                    BrushToolPhase::Outline => {
+                        key_hint(ui, "LMB", "Point");
+                        key_hint(ui, "Enter", "Height");
+                        key_hint(ui, "Backspace", "Remove");
+                        key_hint(ui, "Esc", "Cancel");
+                        key_hint(ui, "RMB", "Cancel");
+                    }
+                    BrushToolPhase::Height => {
+                        key_hint(ui, "Mouse Up/Down", "Height");
+                        key_hint(ui, "Enter", "Create");
+                        key_hint(ui, "LMB", "Create");
+                        key_hint(ui, "Backspace", "Outline");
+                        key_hint(ui, "Esc", "Cancel");
+                        key_hint(ui, "RMB", "Cancel");
+                    }
+                });
+            });
         });
 }
 
@@ -290,35 +300,149 @@ fn key_hint(ui: &mut egui::Ui, key: &str, label: &str) {
         ui.label(
             egui::RichText::new(key)
                 .monospace()
-                .color(egui::Color32::from_rgb(232, 238, 242))
-                .background_color(egui::Color32::from_rgba_unmultiplied(45, 52, 58, 220)),
-        );
-        ui.label(
-            egui::RichText::new(label)
-                .color(egui::Color32::from_rgb(190, 200, 205))
-                .small(),
+                .color(TEXT)
+                .background_color(ELEVATED_BG),
         );
+        ui.label(egui::RichText::new(label).color(TEXT_DIM).small());
     });
 }
 
-fn scene_view_gi_badge(world: &World, ctx: &egui::Context, scene_rect: egui::Rect) {
-    let Some(profile) = world.get_resource::<settings::ActiveCameraRenderProfile>() else {
+fn scene_view_selection_hud(
+    world: &World,
+    ctx: &egui::Context,
+    scene_rect: egui::Rect,
+    selected_entities: &SelectedEntities,
+) {
+    let Some(&primary) = selected_entities.as_slice().first() else {
         return;
     };
-    let (label, color) = match profile.gi_path {
-        settings::GiPath::Forward => ("Forward", egui::Color32::from_rgb(140, 180, 255)),
-        settings::GiPath::SolariDeferred => ("Solari", egui::Color32::from_rgb(255, 170, 90)),
+    let name = world
+        .get::<Name>(primary)
+        .map(|name| name.as_str().to_string())
+        .unwrap_or_else(|| "Selected entity".to_string());
+    let kind = world
+        .get::<shared::ActorKind>(primary)
+        .map(|kind| format!("{kind:?}"))
+        .unwrap_or_else(|| "Entity".to_string());
+    let count = selected_entities.len();
+    let selection_detail = if count > 1 {
+        format!("{kind}  /  {count} selected")
+    } else {
+        kind
     };
-    egui::Area::new(egui::Id::new("scene_view_gi_badge"))
-        .fixed_pos(scene_rect.right_bottom() + egui::vec2(-148.0, -22.0))
+
+    let pick_detail = world.get_resource::<ViewportPickStack>().and_then(|stack| {
+        (stack.entities.len() > 1 && stack.entities.contains(&primary)).then(|| {
+            format!(
+                "Pick {}/{}",
+                stack.index.min(stack.entities.len() - 1) + 1,
+                stack.entities.len()
+            )
+        })
+    });
+    let top_offset = if scene_rect.width() < 1100.0 {
+        50.0
+    } else {
+        10.0
+    };
+
+    egui::Area::new(egui::Id::new("scene_view_selection_hud"))
+        .fixed_pos(scene_rect.right_top() + egui::vec2(-10.0, top_offset))
+        .pivot(egui::Align2::RIGHT_TOP)
         .interactable(false)
         .show(ctx, |ui| {
-            egui::Frame::NONE
-                .fill(egui::Color32::from_black_alpha(160))
-                .inner_margin(egui::Margin::symmetric(8, 4))
-                .show(ui, |ui| {
-                    ui.colored_label(color, label);
+            overlay_chip_frame().show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label(phosphor_icon(icons::CROSSHAIR, 17.0).color(SELECTION));
+                    ui.vertical(|ui| {
+                        ui.set_max_width(260.0);
+                        ui.add(
+                            egui::Label::new(egui::RichText::new(&name).color(TEXT).strong())
+                                .truncate(),
+                        );
+                        ui.label(
+                            egui::RichText::new(&selection_detail)
+                                .color(TEXT_DIM)
+                                .small(),
+                        );
+                    });
+                    if let Some(pick_detail) = pick_detail {
+                        ui.separator();
+                        ui.label(
+                            egui::RichText::new(pick_detail)
+                                .color(ACCENT)
+                                .monospace()
+                                .small(),
+                        );
+                    }
                 });
+            });
+        });
+}
+
+fn scene_view_orientation_widget(world: &mut World, ctx: &egui::Context, scene_rect: egui::Rect) {
+    let rotation = {
+        let mut cameras = world.query_filtered::<(&Camera, &GlobalTransform), With<EditorCamera>>();
+        let mut rotation = None;
+        for (camera, transform) in cameras.iter(world) {
+            rotation.get_or_insert(transform.rotation());
+            if camera.is_active {
+                rotation = Some(transform.rotation());
+                break;
+            }
+        }
+        rotation
+    };
+    let Some(rotation) = rotation else {
+        return;
+    };
+
+    egui::Area::new(egui::Id::new("scene_view_orientation_widget"))
+        .fixed_pos(scene_rect.right_bottom() + egui::vec2(-10.0, -48.0))
+        .pivot(egui::Align2::RIGHT_BOTTOM)
+        .interactable(false)
+        .show(ctx, |ui| {
+            overlay_chip_frame().show(ui, |ui| {
+                let (rect, _) =
+                    ui.allocate_exact_size(egui::vec2(72.0, 72.0), egui::Sense::hover());
+                let painter = ui.painter_at(rect);
+                let center = rect.center();
+                painter.circle_filled(center, 4.0, egui::Color32::from_rgb(210, 214, 219));
+
+                let view_rotation = rotation.inverse();
+                let mut axes = [
+                    ("X", view_rotation * Vec3::X, AXIS_X),
+                    ("Y", view_rotation * Vec3::Y, AXIS_Y),
+                    ("Z", view_rotation * Vec3::Z, AXIS_Z),
+                ];
+                axes.sort_by(|left, right| {
+                    left.1
+                        .z
+                        .partial_cmp(&right.1.z)
+                        .unwrap_or(std::cmp::Ordering::Equal)
+                });
+                for (label, axis, color) in axes {
+                    let endpoint = center + egui::vec2(axis.x, -axis.y) * 27.0;
+                    let facing = axis.z <= 0.0;
+                    let color = if facing {
+                        color
+                    } else {
+                        color.gamma_multiply(0.48)
+                    };
+                    painter.line_segment(
+                        [center, endpoint],
+                        egui::Stroke::new(if facing { 2.2 } else { 1.2 }, color),
+                    );
+                    painter.circle_filled(endpoint, if facing { 9.0 } else { 7.0 }, color);
+                    painter.text(
+                        endpoint,
+                        egui::Align2::CENTER_CENTER,
+                        label,
+                        egui::FontId::monospace(10.0),
+                        egui::Color32::from_rgb(18, 20, 22),
+                    );
+                }
+            });
         });
 }
 
@@ -333,17 +457,26 @@ fn scene_view_volume_hud(world: &World, ctx: &egui::Context, scene_rect: egui::R
         .fixed_pos(scene_rect.left_bottom() + egui::vec2(8.0, -56.0))
         .interactable(false)
         .show(ctx, |ui| {
-            egui::Frame::NONE
-                .fill(egui::Color32::from_black_alpha(150))
-                .inner_margin(egui::Margin::symmetric(8, 4))
-                .show(ui, |ui| {
-                    ui.label(format!(
-                        "Volume: {} ({:.0}%, {} overrides)",
-                        primary.label,
-                        primary.weight * 100.0,
-                        primary.override_count
-                    ));
+            overlay_chip_frame().show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label(phosphor_icon(icons::CUBE, 14.0).color(SELECTION));
+                    ui.label(
+                        egui::RichText::new(&primary.label)
+                            .color(TEXT)
+                            .strong()
+                            .small(),
+                    );
+                    ui.label(
+                        egui::RichText::new(format!(
+                            "{:.0}% / {} overrides",
+                            primary.weight * 100.0,
+                            primary.override_count
+                        ))
+                        .color(TEXT_DIM)
+                        .small(),
+                    );
                 });
+            });
         });
 }
 
@@ -358,7 +491,7 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
             viewport_toolbar_frame().show(ui, |ui| {
                 panel_toolbar_row(ui, |ui| {
                     let gizmo_mode = *world.resource::<crate::gizmos::EditorGizmoMode>();
-                    if tool_button(
+                    if tool_button_accent(
                         ui,
                         icons::ARROWS_OUT_CARDINAL,
                         gizmo_mode == EditorGizmoMode::Translate,
@@ -368,7 +501,7 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
                     {
                         super::helpers::set_gizmo_mode(world, EditorGizmoMode::Translate);
                     }
-                    if tool_button(
+                    if tool_button_accent(
                         ui,
                         icons::ARROWS_CLOCKWISE,
                         gizmo_mode == EditorGizmoMode::Rotate,
@@ -378,7 +511,7 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
                     {
                         super::helpers::set_gizmo_mode(world, EditorGizmoMode::Rotate);
                     }
-                    if tool_button(
+                    if tool_button_accent(
                         ui,
                         icons::ARROWS_IN_LINE_HORIZONTAL,
                         gizmo_mode == EditorGizmoMode::Scale,
@@ -459,6 +592,14 @@ fn scene_view_overlay_toolbar(world: &mut World, ctx: &egui::Context, scene_rect
                         if tool_button(ui, icons::MAGNET, snap, "Snap translation").clicked() {
                             settings.snap_translate = !settings.snap_translate;
                         }
+                        if settings.snap_translate {
+                            ui.label(
+                                egui::RichText::new(format!("{:.2}m", settings.snap_increment))
+                                    .color(SELECTION)
+                                    .monospace()
+                                    .small(),
+                            );
+                        }
                     }
 
                     if let Some(mut visualizers) =
@@ -532,7 +673,8 @@ fn scene_options_popover(
                     ui.checkbox(&mut settings.snap_translate, "Snap translation");
                     ui.add(
                         egui::Slider::new(&mut settings.snap_increment, 0.25..=4.0)
-                            .text("Snap step"),
+                            .text("Snap step")
+                            .suffix(" m"),
                     );
                 }
                 if let Some(mut gizmo_options) = world.get_resource_mut::<GizmoOptions>() {
@@ -564,6 +706,7 @@ fn scene_options_popover(
                                 ui.checkbox(&mut visualizers.show_actor_icon_actor, "Actors");
                                 ui.checkbox(&mut visualizers.show_actor_icon_mesh, "Meshes");
                                 ui.checkbox(&mut visualizers.show_actor_icon_light, "Lights");
+                                ui.checkbox(&mut visualizers.show_actor_icon_audio, "Audio");
                                 ui.checkbox(&mut visualizers.show_actor_icon_physics, "Physics");
                                 ui.checkbox(&mut visualizers.show_actor_icon_gameplay, "Gameplay");
                                 ui.checkbox(&mut visualizers.show_actor_icon_volume, "Volumes");
@@ -578,7 +721,10 @@ fn scene_options_popover(
                         ui.separator();
                         ui.checkbox(&mut visualizers.show_colliders, "Colliders");
                         ui.checkbox(&mut visualizers.show_lights, "Lights");
+                        ui.checkbox(&mut visualizers.show_audio, "Audio ranges");
                         ui.checkbox(&mut visualizers.show_spawns, "Player spawns");
+                        ui.checkbox(&mut visualizers.show_gameplay, "Gameplay markers");
+                        ui.checkbox(&mut visualizers.show_volumes, "Volumes");
                         ui.checkbox(
                             &mut visualizers.show_prefab_model_anchors,
                             "Prefab/model anchors",
@@ -669,29 +815,74 @@ fn viewport_asset_drop_ui(
     viewport_rect: egui::Rect,
     selected: &SelectedEntities,
 ) {
+    let pointer_pos = ui.input(|input| input.pointer.hover_pos());
+    let drag_selection = world
+        .resource::<EditorAssets>()
+        .dragging_selection()
+        .cloned();
+    let drag_descriptor = drag_selection
+        .as_ref()
+        .and_then(|selection| asset_drag_descriptor(world, selection, selected));
+    let over_viewport = pointer_pos.is_some_and(|pos| viewport_rect.contains(pos));
+
+    if let (Some(pointer), Some((icon, label, action))) = (pointer_pos, drag_descriptor.as_ref()) {
+        draw_asset_drag_preview(
+            ui,
+            viewport_rect,
+            pointer,
+            *icon,
+            label,
+            action,
+            over_viewport,
+        );
+    }
+
+    if drag_selection.is_some() && over_viewport {
+        ui.painter().rect_stroke(
+            viewport_rect.shrink(2.0),
+            0.0,
+            egui::Stroke::new(2.0, ACCENT_HOVER),
+            egui::StrokeKind::Inside,
+        );
+    }
+
     let pointer_released = ui.input(|input| input.pointer.any_released());
     if !pointer_released {
         return;
     }
 
-    let pointer_pos = ui.input(|input| input.pointer.hover_pos());
     if !pointer_pos.is_some_and(|pos| viewport_rect.contains(pos)) {
         world.resource_mut::<EditorAssets>().clear_drag();
         return;
     }
 
-    let selection = {
-        let assets = world.resource::<EditorAssets>();
-        assets.dragging_selection().cloned()
-    };
     world.resource_mut::<EditorAssets>().clear_drag();
 
-    let Some(selection) = selection else {
+    let Some(selection) = drag_selection else {
         return;
     };
     let placement = viewport_ground_position(world, pointer_pos.unwrap(), viewport_rect)
         .map(|pos| snap_translation(pos, world.resource::<ViewportSettings>()))
         .unwrap_or(Vec3::ZERO);
+    if matches!(
+        selection,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::AnimationClip,
+            ..
+        }
+    ) {
+        if let Some(entity) = selected
+            .as_slice()
+            .iter()
+            .copied()
+            .find(|entity| world.get::<shared::ModelRef>(*entity).is_some())
+        {
+            assign_animation_clip_operator(world, selection, entity);
+        } else {
+            place_subasset_operator(world, selection, placement);
+        }
+        return;
+    }
     if matches!(
         selection,
         AssetSelection::SubAsset {
@@ -702,6 +893,15 @@ fn viewport_asset_drop_ui(
         place_subasset_operator(world, selection, placement);
         return;
     }
+    if matches!(
+        selection,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Skeleton,
+            ..
+        }
+    ) {
+        return;
+    }
 
     if let AssetSelection::SubAsset {
         kind: AssetSubAssetKind::Texture,
@@ -730,6 +930,19 @@ fn viewport_asset_drop_ui(
     let Some(asset) = asset else {
         return;
     };
+    if matches!(asset.kind, crate::assets::EditorAssetKind::AudioClip) {
+        if let Some(entity) = selected
+            .as_slice()
+            .iter()
+            .copied()
+            .find(|entity| world.get::<shared::AudioSourceDesc>(*entity).is_some())
+        {
+            assign_audio_clip_operator(world, asset, entity);
+        } else {
+            place_asset_operator(world, asset, placement);
+        }
+        return;
+    }
     match asset.kind {
         crate::assets::EditorAssetKind::Texture => {
             apply_texture_operator(world, asset, selected);
@@ -744,3 +957,204 @@ fn viewport_asset_drop_ui(
 
     place_asset_operator(world, asset, placement);
 }
+
+fn asset_drag_descriptor(
+    world: &World,
+    selection: &AssetSelection,
+    selected: &SelectedEntities,
+) -> Option<(egui_phosphor_icons::Icon, String, String)> {
+    let assets = world.resource::<EditorAssets>();
+    let asset = assets.asset_for_selection(selection)?;
+    let icon = match selection {
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Mesh,
+            ..
+        } => icons::CUBE,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Material,
+            ..
+        } => icons::PAINT_BRUSH,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Texture,
+            ..
+        } => icons::IMAGE,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Skeleton,
+            ..
+        } => icons::BONE,
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::AnimationClip,
+            ..
+        } => icons::FILM_STRIP,
+        _ => kind_icon(&asset.kind),
+    };
+    let label = match selection {
+        AssetSelection::SubAsset { label, .. } => label.clone(),
+        _ => asset.label.clone(),
+    };
+    let action = match selection {
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Texture,
+            ..
+        } if !selected.is_empty() => "Apply texture to selection",
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Material,
+            ..
+        } if !selected.is_empty() => "Apply material to selection",
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::Skeleton,
+            ..
+        } => "Inspect skeleton",
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::AnimationClip,
+            ..
+        } if selected
+            .as_slice()
+            .iter()
+            .any(|entity| world.get::<shared::ModelRef>(*entity).is_some()) =>
+        {
+            "Assign clip to animated actor"
+        }
+        AssetSelection::SubAsset {
+            kind: AssetSubAssetKind::AnimationClip,
+            ..
+        } => "Create animated actor",
+        _ => match asset.kind {
+            crate::assets::EditorAssetKind::Texture if !selected.is_empty() => {
+                "Apply texture to selection"
+            }
+            crate::assets::EditorAssetKind::Material if !selected.is_empty() => {
+                "Apply material to selection"
+            }
+            crate::assets::EditorAssetKind::AudioClip
+                if selected
+                    .as_slice()
+                    .iter()
+                    .any(|entity| world.get::<shared::AudioSourceDesc>(*entity).is_some()) =>
+            {
+                "Assign clip to audio source"
+            }
+            crate::assets::EditorAssetKind::AudioClip => "Create audio source",
+            _ => "Place in scene",
+        },
+    };
+    Some((icon, label, action.to_string()))
+}
+
+fn draw_asset_drag_preview(
+    ui: &egui::Ui,
+    viewport_rect: egui::Rect,
+    pointer: egui::Pos2,
+    icon: egui_phosphor_icons::Icon,
+    label: &str,
+    action: &str,
+    over_viewport: bool,
+) {
+    if over_viewport {
+        let painter = ui.painter();
+        painter.circle_filled(pointer, 3.0, ACCENT_HOVER);
+        painter.circle_stroke(pointer, 11.0, egui::Stroke::new(1.5, ACCENT_HOVER));
+        painter.line_segment(
+            [
+                pointer - egui::vec2(17.0, 0.0),
+                pointer - egui::vec2(7.0, 0.0),
+            ],
+            egui::Stroke::new(1.5, ACCENT_HOVER),
+        );
+        painter.line_segment(
+            [
+                pointer + egui::vec2(7.0, 0.0),
+                pointer + egui::vec2(17.0, 0.0),
+            ],
+            egui::Stroke::new(1.5, ACCENT_HOVER),
+        );
+        painter.line_segment(
+            [
+                pointer - egui::vec2(0.0, 17.0),
+                pointer - egui::vec2(0.0, 7.0),
+            ],
+            egui::Stroke::new(1.5, ACCENT_HOVER),
+        );
+        painter.line_segment(
+            [
+                pointer + egui::vec2(0.0, 7.0),
+                pointer + egui::vec2(0.0, 17.0),
+            ],
+            egui::Stroke::new(1.5, ACCENT_HOVER),
+        );
+    }
+
+    let content = ui.ctx().content_rect();
+    let pos = egui::pos2(
+        (pointer.x + 20.0).min(content.right() - 258.0),
+        (pointer.y + 20.0).min(content.bottom() - 64.0),
+    );
+    egui::Area::new(egui::Id::new("asset_drag_preview"))
+        .fixed_pos(pos)
+        .default_size(egui::vec2(246.0, 60.0))
+        .order(egui::Order::Tooltip)
+        .interactable(false)
+        .show(ui.ctx(), |ui| {
+            ui.set_min_size(egui::vec2(246.0, 60.0));
+            ui.set_max_size(egui::vec2(246.0, 60.0));
+            overlay_chip_frame().show(ui, |ui| {
+                ui.set_width(228.0);
+                ui.horizontal(|ui| {
+                    ui.label(phosphor_icon(icon, 20.0).color(if over_viewport {
+                        ACCENT_HOVER
+                    } else {
+                        TEXT_DIM
+                    }));
+                    ui.vertical(|ui| {
+                        ui.spacing_mut().item_spacing.y = 1.0;
+                        ui.label(egui::RichText::new(label).strong().color(TEXT));
+                        ui.label(
+                            egui::RichText::new(if over_viewport {
+                                action
+                            } else {
+                                "Drag into the viewport"
+                            })
+                            .size(11.0)
+                            .color(if over_viewport {
+                                ACCENT_HOVER
+                            } else {
+                                TEXT_MUTED
+                            }),
+                        );
+                    });
+                });
+            });
+        });
+
+    if over_viewport {
+        let corner = 16.0;
+        let inset = viewport_rect.shrink(8.0);
+        for (a, b, c) in [
+            (
+                inset.left_top(),
+                egui::vec2(corner, 0.0),
+                egui::vec2(0.0, corner),
+            ),
+            (
+                inset.right_top(),
+                egui::vec2(-corner, 0.0),
+                egui::vec2(0.0, corner),
+            ),
+            (
+                inset.left_bottom(),
+                egui::vec2(corner, 0.0),
+                egui::vec2(0.0, -corner),
+            ),
+            (
+                inset.right_bottom(),
+                egui::vec2(-corner, 0.0),
+                egui::vec2(0.0, -corner),
+            ),
+        ] {
+            ui.painter()
+                .line_segment([a, a + b], egui::Stroke::new(3.0, ACCENT_HOVER));
+            ui.painter()
+                .line_segment([a, a + c], egui::Stroke::new(3.0, ACCENT_HOVER));
+        }
+    }
+}
diff --git a/crates/editor/src/ui/widgets.rs b/crates/editor/src/ui/widgets.rs
index 2e2d50f..5283e16 100644
--- a/crates/editor/src/ui/widgets.rs
+++ b/crates/editor/src/ui/widgets.rs
@@ -1,9 +1,14 @@
 //! Reusable editor widgets: icon buttons, tool toggles, menu labels.
 
+use std::hash::Hash;
+
 use bevy_egui::egui::{self, Button, FontId, RichText, Ui, WidgetText};
 use egui_phosphor_icons::Icon;
 
-use super::theme::{ACCENT, ACCENT_HOVER, ELEVATED_BG};
+use super::theme::{
+    ACCENT, ACCENT_HOVER, BORDER, ELEVATED_BG, SELECTION, SELECTION_BG, SUCCESS, TEXT_MUTED,
+    TEXT_SELECTED, WIDGET_BG,
+};
 
 const PHOSPHOR: &str = "phosphor-regular";
 
@@ -15,42 +20,61 @@ pub fn phosphor_icon_text(icon: &str, size: f32) -> RichText {
     RichText::new(icon).font(FontId::new(size, egui::FontFamily::Name(PHOSPHOR.into())))
 }
 
-/// Large transport control (Play / Pause / Stop / Eject) — icon only, tooltip for label.
+/// Large transport control (Play / Pause / Stop / Eject), icon-only with a tooltip.
 pub fn transport_button_large(
     ui: &mut Ui,
+    id_salt: impl Hash,
     icon: Icon,
     tooltip: &str,
     accent: bool,
 ) -> egui::Response {
-    const SIZE: f32 = 44.0;
-    const ICON_PX: f32 = 22.0;
+    const SIZE: f32 = 40.0;
+    const ICON_PX: f32 = 20.0;
 
     let fill = if accent {
-        ACCENT
+        SUCCESS
     } else {
-        ELEVATED_BG.linear_multiply(0.85)
+        ELEVATED_BG.linear_multiply(0.9)
     };
-    ui.add(
-        Button::new(phosphor_icon(icon, ICON_PX))
-            .fill(fill)
-            .stroke(egui::Stroke::new(
-                1.0,
-                if accent {
-                    ACCENT_HOVER
-                } else {
-                    super::theme::BORDER
-                },
-            ))
-            .min_size(egui::vec2(SIZE, SIZE))
-            .corner_radius(5.0),
-    )
-    .on_hover_text(tooltip)
+    let (_, rect) = ui.allocate_space(egui::vec2(SIZE, SIZE));
+    let response = ui.interact(rect, ui.make_persistent_id(id_salt), egui::Sense::click());
+    response.widget_info(|| {
+        egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), tooltip)
+    });
+    let fill = if response.is_pointer_button_down_on() {
+        fill.linear_multiply(0.82)
+    } else if response.hovered() {
+        fill.linear_multiply(1.15)
+    } else {
+        fill
+    };
+    let stroke = egui::Stroke::new(
+        if response.hovered() { 1.5 } else { 1.0 },
+        if accent {
+            SUCCESS.linear_multiply(1.15)
+        } else if response.hovered() {
+            TEXT_MUTED
+        } else {
+            BORDER
+        },
+    );
+    ui.painter()
+        .rect(rect, 6.0, fill, stroke, egui::StrokeKind::Inside);
+    ui.painter().text(
+        rect.center(),
+        egui::Align2::CENTER_CENTER,
+        icon.as_str(),
+        FontId::new(ICON_PX, egui::FontFamily::Name(PHOSPHOR.into())),
+        TEXT_SELECTED,
+    );
+    response.on_hover_text(tooltip)
 }
 
 pub fn icon_button(ui: &mut Ui, icon: Icon, tooltip: &str) -> egui::Response {
     ui.add(
-        Button::new(phosphor_icon(icon, 18.0))
-            .frame(false)
+        Button::new(phosphor_icon(icon, 17.0))
+            .fill(WIDGET_BG.linear_multiply(0.78))
+            .stroke(egui::Stroke::new(1.0, BORDER))
             .min_size(egui::vec2(32.0, 32.0)),
     )
     .on_hover_text(tooltip)
@@ -59,31 +83,56 @@ pub fn icon_button(ui: &mut Ui, icon: Icon, tooltip: &str) -> egui::Response {
 pub fn icon_button_small(ui: &mut Ui, icon: Icon, tooltip: &str) -> egui::Response {
     ui.add(
         Button::new(phosphor_icon(icon, 16.0))
-            .frame(false)
-            .min_size(egui::vec2(22.0, 22.0)),
+            .fill(WIDGET_BG.linear_multiply(0.72))
+            .stroke(egui::Stroke::new(1.0, BORDER))
+            .min_size(egui::vec2(27.0, 27.0))
+            .corner_radius(4.0),
     )
     .on_hover_text(tooltip)
 }
 
 pub fn tool_button(ui: &mut Ui, icon: Icon, selected: bool, tooltip: &str) -> egui::Response {
+    tool_button_with_color(ui, icon, selected, tooltip, SELECTION_BG, SELECTION)
+}
+
+pub fn tool_button_accent(
+    ui: &mut Ui,
+    icon: Icon,
+    selected: bool,
+    tooltip: &str,
+) -> egui::Response {
+    tool_button_with_color(
+        ui,
+        icon,
+        selected,
+        tooltip,
+        ACCENT.linear_multiply(0.84),
+        ACCENT_HOVER,
+    )
+}
+
+fn tool_button_with_color(
+    ui: &mut Ui,
+    icon: Icon,
+    selected: bool,
+    tooltip: &str,
+    selected_fill: egui::Color32,
+    selected_stroke: egui::Color32,
+) -> egui::Response {
     let fill = if selected {
-        ACCENT
+        selected_fill
     } else {
-        ELEVATED_BG.linear_multiply(0.6)
+        WIDGET_BG.linear_multiply(0.82)
     };
     ui.add(
-        Button::new(phosphor_icon(icon, 16.0))
+        Button::new(phosphor_icon(icon, 17.0))
             .fill(fill)
             .stroke(egui::Stroke::new(
                 1.0,
-                if selected {
-                    ACCENT
-                } else {
-                    super::theme::BORDER
-                },
+                if selected { selected_stroke } else { BORDER },
             ))
-            .min_size(egui::vec2(26.0, 26.0))
-            .corner_radius(3.0),
+            .min_size(egui::vec2(30.0, 30.0))
+            .corner_radius(4.0),
     )
     .on_hover_text(tooltip)
 }
diff --git a/crates/editor/src/viewport/actor_icons.rs b/crates/editor/src/viewport/actor_icons.rs
index aa9fadb..9d0a6f8 100644
--- a/crates/editor/src/viewport/actor_icons.rs
+++ b/crates/editor/src/viewport/actor_icons.rs
@@ -14,14 +14,15 @@ use bevy::render::render_resource::{
 };
 use bevy::shader::ShaderRef;
 use shared::{
-    ActorKind, AuthoringLightKind, ColliderDesc, LevelObject, LightDesc, ModelRef, ObjectiveMarker,
-    PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabInstance, PrefabRef, Primitive,
-    RaytracingExcluded, StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
+    ActorKind, AudioListenerDesc, AudioSourceDesc, AuthoringLightKind, ColliderDesc, LevelObject,
+    LightDesc, ModelRef, ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc,
+    PrefabInstance, PrefabRef, Primitive, RaytracingExcluded, StaticMeshRenderer, TeamSpawn,
+    TriggerVolume, WeaponSpawn,
 };
 
 use crate::camera::EditorCamera;
 use crate::infra::EditorOnly;
-use crate::state::scene_tools_active;
+use crate::state::{EditorMode, PlayPossession};
 use crate::ui::UiState;
 use crate::viewport::ViewportDisplayMode;
 use crate::visualizers::EditorVisualizationSettings;
@@ -167,6 +168,8 @@ enum ActorIconImage {
     LightPoint,
     LightSpot,
     LightDirectional,
+    AudioSource,
+    AudioListener,
     PhysicsCollider,
     GameSpawn,
     GameTrigger,
@@ -180,6 +183,7 @@ enum ActorIconCategory {
     Actor,
     Mesh,
     Light,
+    Audio,
     Physics,
     Gameplay,
     Volume,
@@ -208,6 +212,8 @@ struct ActorIconComponents {
     has_post_process_volume: bool,
     has_team_spawn: bool,
     has_objective: bool,
+    has_audio_source: bool,
+    has_audio_listener: bool,
     has_physics: bool,
 }
 
@@ -232,7 +238,7 @@ impl Plugin for ActorIconsPlugin {
         app.init_resource::<ActorIconSettings>()
             .add_plugins(MaterialPlugin::<ActorIconOverlayMaterial>::default())
             .add_systems(Startup, init_actor_icon_assets)
-            .add_systems(Update, sync_actor_icons.run_if(scene_tools_active));
+            .add_systems(Update, sync_actor_icons);
     }
 }
 
@@ -314,6 +320,8 @@ fn init_actor_icon_assets(
         (ActorIconImage::LightPoint, ICON_09_LIGHT_POINT),
         (ActorIconImage::LightSpot, ICON_10_LIGHT_SPOT),
         (ActorIconImage::LightDirectional, ICON_11_LIGHT_DIRECTIONAL),
+        (ActorIconImage::AudioSource, ICON_15_AUDIO_SOURCE),
+        (ActorIconImage::AudioListener, ICON_16_AUDIO_LISTENER),
         (ActorIconImage::PhysicsCollider, ICON_17_PHYSICS_COLLIDER),
         (ActorIconImage::GameSpawn, ICON_21_GAME_SPAWN),
         (ActorIconImage::GameTrigger, ICON_22_GAME_TRIGGER),
@@ -343,6 +351,8 @@ fn init_actor_icon_assets(
 
 #[allow(clippy::type_complexity, clippy::too_many_arguments)]
 fn sync_actor_icons(
+    mode: Res<State<EditorMode>>,
+    possession: Res<PlayPossession>,
     display: Res<ViewportDisplayMode>,
     settings: Res<EditorVisualizationSettings>,
     icon_settings: Res<ActorIconSettings>,
@@ -376,11 +386,14 @@ fn sync_actor_icons(
         ),
         (With<LevelObject>, Without<EditorOnly>),
     >,
+    audio: Query<(Has<AudioSourceDesc>, Has<AudioListenerDesc>)>,
     physics: Query<(), Or<(With<PhysicsBody>, With<ColliderDesc>)>>,
 ) {
     let camera = active_editor_camera(&camera_query);
     let mut desired = HashMap::new();
-    if !display.clean_game_view && settings.enabled && settings.show_actor_icons {
+    let tools_active = *mode.get() == EditorMode::Editing
+        || (*mode.get() == EditorMode::Playing && *possession == PlayPossession::Ejected);
+    if tools_active && !display.clean_game_view && settings.enabled && settings.show_actor_icons {
         for (
             target,
             global,
@@ -399,6 +412,7 @@ fn sync_actor_icons(
             has_objective,
         ) in &actor_roots
         {
+            let (has_audio_source, has_audio_listener) = audio.get(target).unwrap_or_default();
             let components = ActorIconComponents {
                 kind: kind.copied(),
                 light_kind: light.map(|light| light.kind),
@@ -414,6 +428,8 @@ fn sync_actor_icons(
                 has_post_process_volume,
                 has_team_spawn,
                 has_objective,
+                has_audio_source,
+                has_audio_listener,
                 has_physics: physics.contains(target),
             };
             let spec = icon_for_actor_components(components);
@@ -466,6 +482,7 @@ fn sync_actor_icons(
         if existing_targets.contains(&target) {
             continue;
         }
+        let (has_audio_source, has_audio_listener) = audio.get(target).unwrap_or_default();
         let components = ActorIconComponents {
             kind: kind.copied(),
             light_kind: light.map(|light| light.kind),
@@ -481,6 +498,8 @@ fn sync_actor_icons(
             has_post_process_volume,
             has_team_spawn,
             has_objective,
+            has_audio_source,
+            has_audio_listener,
             has_physics: physics.contains(target),
         };
         let spec = icon_for_actor_components(components);
@@ -578,6 +597,7 @@ fn icon_category_enabled(
         ActorIconCategory::Actor => settings.show_actor_icon_actor,
         ActorIconCategory::Mesh => settings.show_actor_icon_mesh,
         ActorIconCategory::Light => settings.show_actor_icon_light,
+        ActorIconCategory::Audio => settings.show_actor_icon_audio,
         ActorIconCategory::Physics => settings.show_actor_icon_physics,
         ActorIconCategory::Gameplay => settings.show_actor_icon_gameplay,
         ActorIconCategory::Volume => settings.show_actor_icon_volume,
@@ -712,6 +732,26 @@ fn icon_for_actor_components(components: ActorIconComponents) -> ActorIconSpec {
                 warning
             }
         }
+        ActorKind::AudioSource => {
+            if components.has_audio_source {
+                ActorIconSpec {
+                    image: ActorIconImage::AudioSource,
+                    category: ActorIconCategory::Audio,
+                }
+            } else {
+                warning
+            }
+        }
+        ActorKind::AudioListener => {
+            if components.has_audio_listener {
+                ActorIconSpec {
+                    image: ActorIconImage::AudioListener,
+                    category: ActorIconCategory::Audio,
+                }
+            } else {
+                warning
+            }
+        }
         ActorKind::Empty => {
             if components.has_physics {
                 ActorIconSpec {
@@ -767,6 +807,45 @@ mod tests {
         assert_eq!(spec.category, ActorIconCategory::Physics);
     }
 
+    #[test]
+    fn audio_source_and_listener_use_dedicated_icons() {
+        let source = icon_for_actor_components(ActorIconComponents {
+            kind: Some(ActorKind::AudioSource),
+            has_audio_source: true,
+            ..default()
+        });
+        let listener = icon_for_actor_components(ActorIconComponents {
+            kind: Some(ActorKind::AudioListener),
+            has_audio_listener: true,
+            ..default()
+        });
+
+        assert_eq!(source.image, ActorIconImage::AudioSource);
+        assert_eq!(source.category, ActorIconCategory::Audio);
+        assert_eq!(listener.image, ActorIconImage::AudioListener);
+        assert_eq!(listener.category, ActorIconCategory::Audio);
+    }
+
+    #[test]
+    fn audio_actor_without_matching_descriptor_uses_warning_icon() {
+        let spec = icon_for_actor_components(ActorIconComponents {
+            kind: Some(ActorKind::AudioSource),
+            ..default()
+        });
+
+        assert_eq!(spec.image, ActorIconImage::Warning);
+        assert_eq!(spec.category, ActorIconCategory::Debug);
+    }
+
+    #[test]
+    fn audio_icon_category_respects_its_viewport_toggle() {
+        let mut settings = EditorVisualizationSettings::default();
+        assert!(icon_category_enabled(&settings, ActorIconCategory::Audio));
+
+        settings.show_actor_icon_audio = false;
+        assert!(!icon_category_enabled(&settings, ActorIconCategory::Audio));
+    }
+
     #[test]
     fn perspective_icon_size_uses_view_depth() {
         let camera = GlobalTransform::IDENTITY;
diff --git a/crates/editor/src/viewport/brush_csg.rs b/crates/editor/src/viewport/brush_csg.rs
index 715f090..1d3fcab 100644
--- a/crates/editor/src/viewport/brush_csg.rs
+++ b/crates/editor/src/viewport/brush_csg.rs
@@ -8,6 +8,7 @@ use shared::{
 };
 
 use crate::history::apply_brush_csg_with_history;
+use crate::operators::{ActiveOperator, OperatorPhase, OperatorStatus};
 use crate::scene_io::SceneIo;
 use crate::ui::UiState;
 
@@ -189,14 +190,13 @@ fn run_bounds_csg(world: &mut World, op: BrushCsgOp) {
         selected,
         result,
     });
-    set_status(
-        world,
-        match op {
-            BrushCsgOp::Intersect => "Brush intersect preview: Enter commits, Esc cancels",
-            BrushCsgOp::Merge => "Brush convex merge preview: Enter commits, Esc cancels",
-            BrushCsgOp::Subtract => "Brush subtract preview: Enter commits, Esc cancels",
-        },
-    );
+    let hint = match op {
+        BrushCsgOp::Intersect => "Brush intersect preview: Enter commits, Esc cancels",
+        BrushCsgOp::Merge => "Brush convex merge preview: Enter commits, Esc cancels",
+        BrushCsgOp::Subtract => "Brush subtract preview: Enter commits, Esc cancels",
+    };
+    set_status(world, hint);
+    set_csg_operator_status(world, OperatorPhase::Preview, hint);
 }
 
 fn brush_csg_preview_input(world: &mut World) {
@@ -210,14 +210,7 @@ fn brush_csg_preview_input(world: &mut World) {
         return;
     }
     if escape {
-        if world
-            .resource_mut::<BrushCsgPreview>()
-            .pending
-            .take()
-            .is_some()
-        {
-            set_status(world, "Brush CSG preview canceled");
-        }
+        cancel_csg_preview(world);
         return;
     }
     let Some(pending) = world.resource_mut::<BrushCsgPreview>().pending.take() else {
@@ -226,9 +219,26 @@ fn brush_csg_preview_input(world: &mut World) {
     commit_csg_preview(world, pending);
 }
 
+fn cancel_csg_preview(world: &mut World) {
+    if world
+        .resource_mut::<BrushCsgPreview>()
+        .pending
+        .take()
+        .is_some()
+    {
+        set_status(world, "Brush CSG preview canceled");
+        set_csg_operator_status(world, OperatorPhase::Canceled, "Canceled");
+    }
+}
+
 fn commit_csg_preview(world: &mut World, pending: PendingBrushCsg) {
     let Some(primary) = pending.selected.first().copied() else {
         set_status(world, "Brush CSG commit failed: missing primary brush");
+        set_csg_operator_status(
+            world,
+            OperatorPhase::Blocked,
+            "Commit failed: missing primary brush",
+        );
         return;
     };
     if world.get::<BrushDesc>(primary).is_none() {
@@ -236,6 +246,11 @@ fn commit_csg_preview(world: &mut World, pending: PendingBrushCsg) {
             world,
             "Brush CSG commit failed: primary brush no longer exists",
         );
+        set_csg_operator_status(
+            world,
+            OperatorPhase::Blocked,
+            "Commit failed: primary brush no longer exists",
+        );
         return;
     }
     let new_brush = BrushDesc::cuboid(pending.result.size());
@@ -251,14 +266,13 @@ fn commit_csg_preview(world: &mut World, pending: PendingBrushCsg) {
         Vec::new()
     };
     apply_bounds_result(world, primary, pending.result, new_brush, &to_delete);
-    set_status(
-        world,
-        match pending.op {
-            BrushCsgOp::Intersect => "Brush intersect committed",
-            BrushCsgOp::Merge => "Brush convex merge committed",
-            BrushCsgOp::Subtract => "Brush subtract committed",
-        },
-    );
+    let hint = match pending.op {
+        BrushCsgOp::Intersect => "Brush intersect committed",
+        BrushCsgOp::Merge => "Brush convex merge committed",
+        BrushCsgOp::Subtract => "Brush subtract committed",
+    };
+    set_status(world, hint);
+    set_csg_operator_status(world, OperatorPhase::Committed, hint);
 }
 
 fn draw_brush_csg_preview(preview: Res<BrushCsgPreview>, mut gizmos: Gizmos) {
@@ -394,10 +408,24 @@ fn set_status(world: &mut World, status: impl Into<String>) {
     }
 }
 
+fn set_csg_operator_status(world: &mut World, phase: OperatorPhase, hint: impl Into<String>) {
+    if let Some(mut active) = world.get_resource_mut::<ActiveOperator>() {
+        active.status = Some(OperatorStatus {
+            id: "brush.csg".to_string(),
+            label: "Brush CSG".to_string(),
+            phase,
+            hint: hint.into(),
+            warnings: Vec::new(),
+        });
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::history::EditorCommand;
+    use crate::history::{EditorCommand, EditorHistory};
+    use crate::operators::test_harness::{assert_undo_redo_round_trip, OperatorInvariantHarness};
+    use crate::selection::SelectedEntity;
 
     fn bounds(min: Vec3, max: Vec3) -> BrushBounds {
         BrushBounds { min, max }
@@ -432,4 +460,62 @@ mod tests {
 
         assert_eq!(command.label(), "Brush CSG");
     }
+
+    #[test]
+    fn csg_preview_cancel_clears_pending_without_authored_side_effects() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<BrushCsgPreview>();
+        world.resource_mut::<BrushCsgPreview>().pending = Some(PendingBrushCsg {
+            op: BrushCsgOp::Merge,
+            selected: vec![Entity::PLACEHOLDER],
+            result: bounds(Vec3::ZERO, Vec3::ONE),
+        });
+        set_csg_operator_status(
+            &mut world,
+            OperatorPhase::Preview,
+            "Enter commits, Esc cancels",
+        );
+        let harness = OperatorInvariantHarness::capture(&mut world);
+
+        cancel_csg_preview(&mut world);
+
+        harness.assert_canceled(&mut world);
+        assert!(world.resource::<BrushCsgPreview>().pending.is_none());
+    }
+
+    #[test]
+    fn csg_merge_commit_is_one_undo_group_and_round_trips_deleted_brush() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<SelectedEntity>();
+        let primary = world
+            .spawn((LevelObject, BrushDesc::default(), Transform::default()))
+            .id();
+        let secondary = world
+            .spawn((
+                LevelObject,
+                BrushDesc::default(),
+                Transform::from_translation(Vec3::new(0.5, 0.0, 0.0)),
+            ))
+            .id();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let pending = PendingBrushCsg {
+            op: BrushCsgOp::Merge,
+            selected: vec![primary, secondary],
+            result: bounds(Vec3::new(-0.5, -0.5, -0.5), Vec3::new(1.0, 0.5, 0.5)),
+        };
+
+        commit_csg_preview(&mut world, pending);
+
+        harness.assert_committed(&mut world, 1, -1);
+        assert_undo_redo_round_trip(&mut world, 2, 1, |world| {
+            let mut query = world.query_filtered::<Entity, With<LevelObject>>();
+            query.iter(world).count()
+        });
+    }
 }
diff --git a/crates/editor/src/viewport/brush_edit.rs b/crates/editor/src/viewport/brush_edit.rs
index 5a81c15..0d60978 100644
--- a/crates/editor/src/viewport/brush_edit.rs
+++ b/crates/editor/src/viewport/brush_edit.rs
@@ -248,10 +248,15 @@ fn sync_brush_element_gizmo(
     mode: Res<BrushEditMode>,
     selection: Res<BrushElementSelection>,
     mut state: ResMut<BrushElementGizmoState>,
-    brushes: Query<(&BrushDesc, &GlobalTransform)>,
+    mut brushes: Query<(&mut BrushDesc, &GlobalTransform)>,
     mut gizmos: Query<&mut Transform, With<BrushElementGizmo>>,
 ) {
     if !mode.is_element_mode() || matches!(*mode, BrushEditMode::Clip) {
+        if let Some((brush_entity, old_brush)) = take_brush_edit_rollback(&mut state) {
+            if let Ok((mut brush, _)) = brushes.get_mut(brush_entity) {
+                *brush = old_brush;
+            }
+        }
         clear_brush_element_gizmo(&mut commands, &mut state);
         return;
     }
@@ -427,6 +432,19 @@ fn apply_brush_element_gizmo(
     state.changed = false;
 }
 
+fn take_brush_edit_rollback(state: &mut BrushElementGizmoState) -> Option<(Entity, BrushDesc)> {
+    let rollback = if state.changed {
+        state.brush.zip(state.old_brush.take())
+    } else {
+        None
+    };
+    state.old_brush = None;
+    state.old_gizmo = None;
+    state.last_gizmo = None;
+    state.changed = false;
+    rollback
+}
+
 fn clear_brush_element_gizmo(commands: &mut Commands, state: &mut BrushElementGizmoState) {
     if let Some(entity) = state.entity.take() {
         if let Ok(mut entity_mut) = commands.get_entity(entity) {
@@ -587,13 +605,14 @@ fn draw_brush_elements(
     gizmos: &mut Gizmos,
 ) {
     let base_color = match mode {
-        BrushEditMode::Vertex => Color::srgb(0.2, 0.72, 1.0),
-        BrushEditMode::Edge => Color::srgb(1.0, 0.68, 0.24),
-        BrushEditMode::Face => Color::srgb(0.24, 1.0, 0.56),
-        BrushEditMode::Clip => Color::srgb(0.92, 0.36, 1.0),
+        BrushEditMode::Vertex => Color::srgb(0.31, 0.75, 0.88),
+        BrushEditMode::Edge => Color::srgb(0.95, 0.62, 0.2),
+        BrushEditMode::Face => Color::srgb(0.32, 0.82, 0.52),
+        BrushEditMode::Clip => Color::srgb(0.86, 0.42, 0.92),
         BrushEditMode::Object => Color::WHITE,
-    };
-    let selected_color = Color::srgb(1.0, 0.95, 0.2);
+    }
+    .with_alpha(if active { 0.9 } else { 0.38 });
+    let selected_color = Color::srgb(1.0, 0.76, 0.34);
     for face in &brush.faces {
         let vertices = world_vertices(face, transform);
         if vertices.is_empty() {
@@ -613,8 +632,29 @@ fn draw_brush_elements(
             } else {
                 base_color
             };
-            gizmos.sphere(face_center, 0.08, color);
-            gizmos.line(face_center, face_center + normal * 0.55, color);
+            gizmos.sphere(
+                face_center,
+                if active && selected.contains(&key) {
+                    0.11
+                } else {
+                    0.075
+                },
+                color,
+            );
+            gizmos.line(face_center, face_center + normal * 0.65, color);
+            if matches!(mode, BrushEditMode::Face) {
+                for index in 0..vertices.len() {
+                    gizmos.line(
+                        vertices[index],
+                        vertices[(index + 1) % vertices.len()],
+                        color.with_alpha(if active && selected.contains(&key) {
+                            1.0
+                        } else {
+                            0.42
+                        }),
+                    );
+                }
+            }
         }
         for index in 0..vertices.len() {
             let next = (index + 1) % vertices.len();
@@ -628,7 +668,15 @@ fn draw_brush_elements(
                 } else {
                     base_color
                 };
-                gizmos.sphere(vertices[index], 0.06, color);
+                gizmos.sphere(
+                    vertices[index],
+                    if active && selected.contains(&key) {
+                        0.1
+                    } else {
+                        0.055
+                    },
+                    color,
+                );
             }
             if matches!(mode, BrushEditMode::Edge | BrushEditMode::Clip) {
                 let key = BrushElementKey::Edge {
@@ -641,6 +689,10 @@ fn draw_brush_elements(
                     base_color
                 };
                 gizmos.line(vertices[index], vertices[next], color);
+                if active && selected.contains(&key) {
+                    gizmos.sphere(vertices[index], 0.07, color);
+                    gizmos.sphere(vertices[next], 0.07, color);
+                }
             }
         }
     }
@@ -1073,7 +1125,11 @@ fn set_brush_edit_status(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use shared::BrushDesc;
+    use crate::history::EditorHistory;
+    use crate::operators::test_harness::{assert_undo_redo_round_trip, OperatorInvariantHarness};
+    use crate::scene_io::SceneIo;
+    use crate::selection::SelectedEntity;
+    use shared::{BrushDesc, LevelObject};
 
     #[test]
     fn point_inside_convex_polygon_is_detected() {
@@ -1158,4 +1214,87 @@ mod tests {
 
         assert_eq!(command.label(), "Clip Brush");
     }
+
+    #[test]
+    fn clip_commit_is_one_undo_group_and_round_trips_geometry() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<SelectedEntity>();
+        let initial_transform = Transform::default();
+        let initial_brush = BrushDesc::default();
+        let entity = world
+            .spawn((LevelObject, initial_transform, initial_brush.clone()))
+            .id();
+        let face = initial_brush.faces[0].id.clone();
+        let result = clip_preview_result(&initial_brush, &initial_transform, &face).unwrap();
+        let committed = (result.transform, result.brush.clone());
+        let harness = OperatorInvariantHarness::capture(&mut world);
+
+        set_brush_transform_with_history(&mut world, entity, result.transform, result.brush);
+        set_brush_edit_status(
+            &mut world.resource_mut::<ActiveOperator>(),
+            OperatorPhase::Committed,
+            "Brush clip committed",
+        );
+
+        harness.assert_committed(&mut world, 1, 0);
+        assert_undo_redo_round_trip(
+            &mut world,
+            (initial_transform, initial_brush),
+            committed,
+            |world| {
+                (
+                    *world.get::<Transform>(entity).unwrap(),
+                    world.get::<BrushDesc>(entity).unwrap().clone(),
+                )
+            },
+        );
+    }
+
+    #[test]
+    fn escape_from_element_preview_restores_brush_and_despawns_helper() {
+        let mut app = App::new();
+        app.init_resource::<ActiveOperator>()
+            .init_resource::<EditorHistory>()
+            .init_resource::<SceneIo>()
+            .init_resource::<BrushEditMode>()
+            .init_resource::<BrushElementSelection>()
+            .init_resource::<BrushElementGizmoState>()
+            .add_systems(Update, sync_brush_element_gizmo);
+        let initial = BrushDesc::default();
+        let mut preview = initial.clone();
+        preview.faces[0].vertices[0] += Vec3::X * 0.25;
+        let brush_entity = app
+            .world_mut()
+            .spawn((LevelObject, preview, GlobalTransform::default()))
+            .id();
+        let helper = app.world_mut().spawn(BrushElementGizmo).id();
+        *app.world_mut().resource_mut::<BrushEditMode>() = BrushEditMode::Object;
+        *app.world_mut().resource_mut::<BrushElementGizmoState>() = BrushElementGizmoState {
+            entity: Some(helper),
+            brush: Some(brush_entity),
+            old_brush: Some(initial.clone()),
+            old_gizmo: Some(Transform::default()),
+            last_gizmo: Some(Transform::from_translation(Vec3::X)),
+            changed: true,
+        };
+        set_brush_edit_status(
+            &mut app.world_mut().resource_mut::<ActiveOperator>(),
+            OperatorPhase::Canceled,
+            "Object mode",
+        );
+        let harness = OperatorInvariantHarness::capture(app.world_mut());
+
+        app.update();
+
+        harness.assert_canceled(app.world_mut());
+        assert_eq!(app.world().get::<BrushDesc>(brush_entity), Some(&initial));
+        harness.assert_no_helpers::<BrushElementGizmo>(app.world_mut());
+        let state = app.world().resource::<BrushElementGizmoState>();
+        assert!(state.entity.is_none());
+        assert!(state.old_brush.is_none());
+        assert!(!state.changed);
+    }
 }
diff --git a/crates/editor/src/viewport/brush_tool.rs b/crates/editor/src/viewport/brush_tool.rs
index 804a551..18a02db 100644
--- a/crates/editor/src/viewport/brush_tool.rs
+++ b/crates/editor/src/viewport/brush_tool.rs
@@ -380,6 +380,9 @@ fn brush_snapshot_from_convex_points(
         collider: None,
         physics: None,
         light: None,
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
@@ -532,6 +535,10 @@ fn set_brush_tool_status(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::history::EditorHistory;
+    use crate::operators::test_harness::{assert_undo_redo_round_trip, OperatorInvariantHarness};
+    use crate::selection::SelectedEntity;
+    use shared::LevelObject;
 
     #[test]
     fn brush_snapshot_centers_polygon_points() {
@@ -627,4 +634,69 @@ mod tests {
         assert!(status.contains("4.2m"));
         assert!(status.contains("2 convex parts"));
     }
+
+    #[test]
+    fn brush_tool_cancel_resets_modal_state_without_authored_side_effects() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let mut tool = BrushToolState {
+            active: true,
+            phase: BrushToolPhase::Height,
+            vertices: vec![Vec3::ZERO, Vec3::X, Vec3::Z],
+            height: 7.5,
+            height_anchor_pointer_y: Some(200.0),
+            height_anchor_value: 7.5,
+        };
+
+        tool.cancel();
+        set_brush_tool_status(
+            &mut world.resource_mut::<ActiveOperator>(),
+            OperatorPhase::Canceled,
+            "Canceled",
+        );
+
+        harness.assert_canceled(&mut world);
+        assert!(!tool.active);
+        assert_eq!(tool.phase, BrushToolPhase::Outline);
+        assert!(tool.vertices.is_empty());
+        assert_eq!(tool.height, DEFAULT_BRUSH_HEIGHT);
+        assert!(tool.height_anchor_pointer_y.is_none());
+    }
+
+    #[test]
+    fn decomposed_brush_commit_is_one_undo_group() {
+        let mut world = World::new();
+        world.init_resource::<ActiveOperator>();
+        world.init_resource::<EditorHistory>();
+        world.init_resource::<SceneIo>();
+        world.init_resource::<SelectedEntity>();
+        let harness = OperatorInvariantHarness::capture(&mut world);
+        let snapshots = brush_snapshots_from_points(
+            &[
+                Vec3::new(-1.0, 0.0, -1.0),
+                Vec3::new(1.0, 0.0, -1.0),
+                Vec3::new(0.0, 0.0, 0.0),
+                Vec3::new(1.0, 0.0, 1.0),
+                Vec3::new(-1.0, 0.0, 1.0),
+            ],
+            2.0,
+        )
+        .unwrap();
+
+        spawn_many_with_history(&mut world, snapshots);
+        set_brush_tool_status(
+            &mut world.resource_mut::<ActiveOperator>(),
+            OperatorPhase::Committed,
+            "Committed brush.draw (2 parts, 2.0m)",
+        );
+
+        harness.assert_committed(&mut world, 1, 2);
+        assert_undo_redo_round_trip(&mut world, 0, 2, |world| {
+            let mut query = world.query_filtered::<Entity, With<LevelObject>>();
+            query.iter(world).count()
+        });
+    }
 }
diff --git a/crates/editor/src/viewport/gizmos.rs b/crates/editor/src/viewport/gizmos.rs
index 1999353..f6bc536 100644
--- a/crates/editor/src/viewport/gizmos.rs
+++ b/crates/editor/src/viewport/gizmos.rs
@@ -1,10 +1,10 @@
 use bevy::math::Rect;
 use bevy::prelude::*;
 use bevy_egui::EguiContexts;
-use transform_gizmo_bevy::prelude::{GizmoMode, GizmoOptions, GizmoOrientation};
+use transform_gizmo_bevy::prelude::{Color32, GizmoMode, GizmoOptions, GizmoOrientation};
 
 use crate::ui::{viewport_keyboard_shortcuts_active, UiState};
-use crate::viewport::ViewportDisplayMode;
+use crate::viewport::{ViewportDisplayMode, ViewportSettings};
 
 #[derive(Resource, Default, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum EditorGizmoMode {
@@ -27,6 +27,7 @@ impl Plugin for EditorGizmoPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<EditorGizmoMode>()
             .init_resource::<EditorGizmoSpace>()
+            .add_systems(Startup, configure_gizmo_visuals)
             .add_systems(
                 Update,
                 (
@@ -39,6 +40,19 @@ impl Plugin for EditorGizmoPlugin {
     }
 }
 
+fn configure_gizmo_visuals(mut options: ResMut<GizmoOptions>) {
+    options.visuals.x_color = Color32::from_rgb(232, 83, 105);
+    options.visuals.y_color = Color32::from_rgb(91, 201, 130);
+    options.visuals.z_color = Color32::from_rgb(77, 147, 235);
+    options.visuals.s_color = Color32::from_rgb(221, 225, 230);
+    options.visuals.highlight_color = Some(Color32::from_rgb(248, 206, 105));
+    options.visuals.inactive_alpha = 0.9;
+    options.visuals.highlight_alpha = 1.0;
+    options.visuals.stroke_width = 3.0;
+    options.visuals.gizmo_size = 92.0;
+    options.group_targets = true;
+}
+
 fn handle_gizmo_hotkeys(
     keys: Res<ButtonInput<KeyCode>>,
     buttons: Res<ButtonInput<MouseButton>>,
@@ -97,9 +111,10 @@ fn sync_gizmo_viewport_rect(
 fn sync_gizmo_options(
     mode: Res<EditorGizmoMode>,
     space: Res<EditorGizmoSpace>,
+    settings: Res<ViewportSettings>,
     mut options: ResMut<GizmoOptions>,
 ) {
-    if !mode.is_changed() && !space.is_changed() {
+    if !mode.is_changed() && !space.is_changed() && !settings.is_changed() {
         return;
     }
 
@@ -112,5 +127,7 @@ fn sync_gizmo_options(
         EditorGizmoSpace::World => GizmoOrientation::Global,
         EditorGizmoSpace::Local => GizmoOrientation::Local,
     };
+    options.snapping = settings.snap_translate;
+    options.snap_distance = settings.snap_increment.max(0.01);
     options.mode_override = None;
 }
diff --git a/crates/editor/src/viewport/panel.rs b/crates/editor/src/viewport/panel.rs
index 77330b9..97901e2 100644
--- a/crates/editor/src/viewport/panel.rs
+++ b/crates/editor/src/viewport/panel.rs
@@ -269,26 +269,42 @@ fn draw_viewport_grid(
         return;
     }
 
-    let step = settings.snap_increment.max(0.5);
-    let extent = 32.0;
-    let mut x = -extent;
-    while x <= extent {
+    let step = settings.snap_increment.max(0.25);
+    let extent = 40.0;
+    let divisions = (extent / step).ceil() as i32;
+    for index in -divisions..=divisions {
+        let coordinate = index as f32 * step;
+        if coordinate.abs() > extent || index == 0 {
+            continue;
+        }
+        let major = index.rem_euclid(10) == 0;
+        let color = if major {
+            Color::srgba(0.43, 0.46, 0.5, 0.38)
+        } else {
+            Color::srgba(0.36, 0.39, 0.43, 0.2)
+        };
         gizmos.line(
-            Vec3::new(x, 0.0, -extent),
-            Vec3::new(x, 0.0, extent),
-            Color::srgba(0.35, 0.38, 0.42, 0.35),
+            Vec3::new(coordinate, 0.0, -extent),
+            Vec3::new(coordinate, 0.0, extent),
+            color,
         );
-        x += step;
-    }
-    let mut z = -extent;
-    while z <= extent {
         gizmos.line(
-            Vec3::new(-extent, 0.0, z),
-            Vec3::new(extent, 0.0, z),
-            Color::srgba(0.35, 0.38, 0.42, 0.35),
+            Vec3::new(-extent, 0.0, coordinate),
+            Vec3::new(extent, 0.0, coordinate),
+            color,
         );
-        z += step;
     }
+
+    gizmos.line(
+        Vec3::new(-extent, 0.002, 0.0),
+        Vec3::new(extent, 0.002, 0.0),
+        Color::srgba(0.91, 0.33, 0.41, 0.72),
+    );
+    gizmos.line(
+        Vec3::new(0.0, 0.002, -extent),
+        Vec3::new(0.0, 0.002, extent),
+        Color::srgba(0.3, 0.58, 0.92, 0.72),
+    );
 }
 
 /// Stores the current editor camera as a bookmark named by scene path.
diff --git a/crates/editor/src/viewport/rendering_diagnostics.rs b/crates/editor/src/viewport/rendering_diagnostics.rs
index c72a41f..9a17c55 100644
--- a/crates/editor/src/viewport/rendering_diagnostics.rs
+++ b/crates/editor/src/viewport/rendering_diagnostics.rs
@@ -463,6 +463,9 @@ pub fn spawn_post_process_volume_at_camera(world: &mut World) {
         collider: None,
         physics: None,
         light: None,
+        animation_controller: None,
+        audio_source: None,
+        audio_listener: None,
         player_spawn: false,
         model: None,
         prefab: None,
diff --git a/crates/editor/src/viewport/selection.rs b/crates/editor/src/viewport/selection.rs
index f04e28e..1e541a9 100644
--- a/crates/editor/src/viewport/selection.rs
+++ b/crates/editor/src/viewport/selection.rs
@@ -2,11 +2,12 @@ use bevy::ecs::system::SystemParam;
 use bevy::picking::mesh_picking::ray_cast::{MeshRayCast, MeshRayCastSettings, RayCastVisibility};
 use bevy::picking::pointer::{PointerAction, PointerInput, PointerInteraction};
 use bevy::prelude::*;
-use shared::LevelObject;
+use shared::{HydratedPrefabMember, LevelObject};
 use transform_gizmo_bevy::prelude::GizmoTarget;
 
 use crate::camera::EditorCamera;
 use crate::infra::EditorOnly;
+use crate::scene_io::ComposedSceneMember;
 use crate::state::scene_tools_active;
 use crate::state::EditorMode;
 use crate::ui::helpers::ensure_player_spawn_for_edit;
@@ -382,7 +383,15 @@ fn sync_gizmo_targets(
     mut selected: ResMut<SelectedEntity>,
     mut commands: Commands,
     targets: Query<(Entity, Option<&BrushElementGizmo>), With<GizmoTarget>>,
-    level_objects: Query<(), (With<LevelObject>, Without<EditorOnly>)>,
+    level_objects: Query<
+        (),
+        (
+            With<LevelObject>,
+            Without<EditorOnly>,
+            Without<HydratedPrefabMember>,
+            Without<ComposedSceneMember>,
+        ),
+    >,
     editor_only: Query<(), With<EditorOnly>>,
     transforms: Query<(), With<Transform>>,
     hierarchy: Option<Res<HierarchyPanelState>>,
@@ -407,11 +416,11 @@ fn sync_gizmo_targets(
         if brush_element_gizmo.is_some() {
             continue;
         }
-        if !ui_state.selected_entities.contains(entity) {
+        if !ui_state.selected_entities.contains(entity) || !level_objects.contains(entity) {
             commands.entity(entity).remove::<GizmoTarget>();
         }
     }
-    if let Some(entity) = ui_state.selected_entities.as_slice().first().copied() {
+    for entity in ui_state.selected_entities.iter() {
         if level_objects.contains(entity)
             && transforms.contains(entity)
             && !targets.contains(entity)
@@ -423,3 +432,42 @@ fn sync_gizmo_targets(
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn multi_selection_receives_grouped_gizmo_targets() {
+        let mut app = App::new();
+        let first = app
+            .world_mut()
+            .spawn((LevelObject, Transform::default()))
+            .id();
+        let second = app
+            .world_mut()
+            .spawn((LevelObject, Transform::default()))
+            .id();
+
+        let mut ui_state = UiState::default_layout();
+        ui_state.selected_entities.select_replace(first);
+        ui_state.selected_entities.select_maybe_add(second, true);
+        app.insert_resource(ui_state)
+            .init_resource::<SelectedEntity>()
+            .init_resource::<ViewportDisplayMode>()
+            .init_resource::<BrushEditMode>()
+            .add_systems(Update, sync_gizmo_targets);
+
+        app.update();
+        assert!(app.world().get::<GizmoTarget>(first).is_some());
+        assert!(app.world().get::<GizmoTarget>(second).is_some());
+
+        app.world_mut()
+            .resource_mut::<UiState>()
+            .selected_entities
+            .select_replace(first);
+        app.update();
+        assert!(app.world().get::<GizmoTarget>(first).is_some());
+        assert!(app.world().get::<GizmoTarget>(second).is_none());
+    }
+}
diff --git a/crates/editor/src/viewport/selection_outline.rs b/crates/editor/src/viewport/selection_outline.rs
index 4cf18bc..8854755 100644
--- a/crates/editor/src/viewport/selection_outline.rs
+++ b/crates/editor/src/viewport/selection_outline.rs
@@ -1,4 +1,4 @@
-//! Editor selection outline: cheap AABB shells, dual depth pass (rim + x-ray).
+//! Editor selection treatment: active/secondary AABB shells, x-ray, and corner brackets.
 
 use avian3d::prelude::ColliderConstructor;
 use bevy::asset::{load_internal_asset, uuid_handle};
@@ -21,10 +21,10 @@ use crate::viewport::ViewportDisplayMode;
 const SELECTION_OUTLINE_SHADER: Handle<Shader> =
     uuid_handle!("c4e8f1a2-9b3d-4e7c-a1f5-6d2b8e0c4a91");
 
-/// Subtle amber rim on visible faces.
-const VISIBLE_COLOR: Color = Color::srgba(1.0, 0.82, 0.35, 0.22);
-/// Soft cyan through occluders.
-const OCCLUDED_COLOR: Color = Color::srgba(0.35, 0.7, 0.95, 0.15);
+const PRIMARY_VISIBLE_COLOR: Color = Color::srgba(1.0, 0.72, 0.28, 0.56);
+const PRIMARY_OCCLUDED_COLOR: Color = Color::srgba(1.0, 0.66, 0.22, 0.28);
+const SECONDARY_VISIBLE_COLOR: Color = Color::srgba(0.31, 0.75, 0.88, 0.42);
+const SECONDARY_OCCLUDED_COLOR: Color = Color::srgba(0.31, 0.68, 0.82, 0.2);
 const BOUNDS_PADDING: f32 = 1.06;
 
 #[derive(Clone, Copy, ShaderType)]
@@ -50,8 +50,8 @@ pub struct SelectionOutlineOccludedMaterial {
 fn outline_uniform(color: Color, pass_kind: u32) -> OutlineUniform {
     OutlineUniform {
         color: color.into(),
-        rim_power: 10.5,
-        rim_mix: 0.35,
+        rim_power: 5.5,
+        rim_mix: 0.9,
         pass_kind,
     }
 }
@@ -106,16 +106,25 @@ enum SelectionOutlinePass {
     Occluded,
 }
 
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum SelectionOutlineRole {
+    Primary,
+    Secondary,
+}
+
 #[derive(Component)]
 pub(crate) struct SelectionOutlineShell {
     root: Entity,
     pass: SelectionOutlinePass,
+    role: SelectionOutlineRole,
 }
 
 #[derive(Resource)]
 struct SelectionOutlineMaterials {
-    occluded: Handle<SelectionOutlineOccludedMaterial>,
-    visible: Handle<SelectionOutlineVisibleMaterial>,
+    primary_occluded: Handle<SelectionOutlineOccludedMaterial>,
+    primary_visible: Handle<SelectionOutlineVisibleMaterial>,
+    secondary_occluded: Handle<SelectionOutlineOccludedMaterial>,
+    secondary_visible: Handle<SelectionOutlineVisibleMaterial>,
 }
 
 #[derive(Resource)]
@@ -152,7 +161,12 @@ impl Plugin for SelectionOutlinePlugin {
         )
         .add_systems(
             Update,
-            sync_selection_outline_meshes.run_if(scene_tools_active),
+            (
+                sync_selection_outline_meshes,
+                draw_selection_corner_brackets,
+            )
+                .chain()
+                .run_if(scene_tools_active),
         );
     }
 }
@@ -169,11 +183,17 @@ fn init_selection_outline_materials(
     mut commands: Commands,
 ) {
     commands.insert_resource(SelectionOutlineMaterials {
-        visible: visible.add(SelectionOutlineVisibleMaterial {
-            uniform: outline_uniform(VISIBLE_COLOR, 0),
+        primary_visible: visible.add(SelectionOutlineVisibleMaterial {
+            uniform: outline_uniform(PRIMARY_VISIBLE_COLOR, 0),
         }),
-        occluded: occluded.add(SelectionOutlineOccludedMaterial {
-            uniform: outline_uniform(OCCLUDED_COLOR, 1),
+        primary_occluded: occluded.add(SelectionOutlineOccludedMaterial {
+            uniform: outline_uniform(PRIMARY_OCCLUDED_COLOR, 1),
+        }),
+        secondary_visible: visible.add(SelectionOutlineVisibleMaterial {
+            uniform: outline_uniform(SECONDARY_VISIBLE_COLOR, 0),
+        }),
+        secondary_occluded: occluded.add(SelectionOutlineOccludedMaterial {
+            uniform: outline_uniform(SECONDARY_OCCLUDED_COLOR, 1),
         }),
     });
 }
@@ -185,7 +205,7 @@ fn sync_selection_outline_meshes(
     materials: Res<SelectionOutlineMaterials>,
     unit_box: Res<SelectionOutlineUnitBox>,
     mut commands: Commands,
-    shells: Query<(Entity, &SelectionOutlineShell)>,
+    mut shells: Query<(Entity, &SelectionOutlineShell, &mut Transform)>,
     children: Query<&Children>,
     mesh_entities: Query<(Entity, &Mesh3d), With<Mesh3d>>,
     globals: Query<&GlobalTransform>,
@@ -195,16 +215,14 @@ fn sync_selection_outline_meshes(
     colliders: Query<&ColliderDesc>,
     level_objects: Query<(), (With<LevelObject>, Without<EditorOnly>)>,
 ) {
-    if !ui_state.is_changed() && !display.is_changed() {
-        return;
-    }
+    let selected: Vec<Entity> = ui_state.selected_entities.iter().collect();
 
-    let selected: std::collections::HashSet<Entity> = ui_state.selected_entities.iter().collect();
-
-    let mut desired: std::collections::HashMap<(Entity, SelectionOutlinePass), SelectionBounds> =
-        std::collections::HashMap::new();
+    let mut desired: std::collections::HashMap<
+        (Entity, SelectionOutlinePass, SelectionOutlineRole),
+        SelectionBounds,
+    > = std::collections::HashMap::new();
     if !display.clean_game_view {
-        for &root in &selected {
+        for (index, &root) in selected.iter().enumerate() {
             if !level_objects.contains(root) {
                 continue;
             }
@@ -223,24 +241,30 @@ fn sync_selection_outline_meshes(
             if bounds.half_extents.max_element() <= f32::EPSILON {
                 continue;
             }
-            desired.insert((root, SelectionOutlinePass::Occluded), bounds);
-            desired.insert((root, SelectionOutlinePass::Visible), bounds);
+            let role = if index == 0 {
+                SelectionOutlineRole::Primary
+            } else {
+                SelectionOutlineRole::Secondary
+            };
+            desired.insert((root, SelectionOutlinePass::Occluded, role), bounds);
+            desired.insert((root, SelectionOutlinePass::Visible, role), bounds);
         }
     }
 
-    for (shell_entity, shell) in &shells {
-        if !desired.contains_key(&(shell.root, shell.pass)) {
+    let mut existing = std::collections::HashSet::new();
+    for (shell_entity, shell, mut transform) in &mut shells {
+        let key = (shell.root, shell.pass, shell.role);
+        if let Some(bounds) = desired.get(&key) {
+            transform.translation = bounds.center;
+            transform.scale = bounds.half_extents * 2.0;
+            existing.insert(key);
+        } else {
             commands.entity(shell_entity).despawn();
         }
     }
 
-    let existing: std::collections::HashSet<(Entity, SelectionOutlinePass)> = shells
-        .iter()
-        .map(|(_, shell)| (shell.root, shell.pass))
-        .collect();
-
-    for ((root, pass), bounds) in desired {
-        if existing.contains(&(root, pass)) {
+    for ((root, pass, role), bounds) in desired {
+        if existing.contains(&(root, pass, role)) {
             continue;
         }
 
@@ -248,7 +272,7 @@ fn sync_selection_outline_meshes(
             EditorOnly,
             RaytracingExcluded,
             Name::new("Selection Outline"),
-            SelectionOutlineShell { root, pass },
+            SelectionOutlineShell { root, pass, role },
             Mesh3d(unit_box.0.clone()),
             Transform {
                 translation: bounds.center,
@@ -259,13 +283,72 @@ fn sync_selection_outline_meshes(
             ChildOf(root),
         ));
 
-        match pass {
-            SelectionOutlinePass::Occluded => {
-                entity_commands.insert(MeshMaterial3d(materials.occluded.clone()));
+        match (role, pass) {
+            (SelectionOutlineRole::Primary, SelectionOutlinePass::Occluded) => {
+                entity_commands.insert(MeshMaterial3d(materials.primary_occluded.clone()));
             }
-            SelectionOutlinePass::Visible => {
-                entity_commands.insert(MeshMaterial3d(materials.visible.clone()));
+            (SelectionOutlineRole::Primary, SelectionOutlinePass::Visible) => {
+                entity_commands.insert(MeshMaterial3d(materials.primary_visible.clone()));
             }
+            (SelectionOutlineRole::Secondary, SelectionOutlinePass::Occluded) => {
+                entity_commands.insert(MeshMaterial3d(materials.secondary_occluded.clone()));
+            }
+            (SelectionOutlineRole::Secondary, SelectionOutlinePass::Visible) => {
+                entity_commands.insert(MeshMaterial3d(materials.secondary_visible.clone()));
+            }
+        }
+    }
+}
+
+fn draw_selection_corner_brackets(
+    display: Res<ViewportDisplayMode>,
+    mut gizmos: Gizmos,
+    shells: Query<(&SelectionOutlineShell, &GlobalTransform)>,
+) {
+    if display.clean_game_view {
+        return;
+    }
+
+    for (shell, global) in &shells {
+        if shell.pass != SelectionOutlinePass::Visible {
+            continue;
+        }
+        let (scale, rotation, center) = global.to_scale_rotation_translation();
+        let half = scale.abs() * 0.5;
+        if half.max_element() <= f32::EPSILON {
+            continue;
+        }
+        let color = match shell.role {
+            SelectionOutlineRole::Primary => Color::srgba(1.0, 0.76, 0.34, 0.98),
+            SelectionOutlineRole::Secondary => Color::srgba(0.38, 0.78, 0.9, 0.78),
+        };
+        draw_corner_brackets(&mut gizmos, center, rotation, half, color);
+    }
+}
+
+fn draw_corner_brackets(
+    gizmos: &mut Gizmos,
+    center: Vec3,
+    rotation: Quat,
+    half: Vec3,
+    color: Color,
+) {
+    let lengths = (half * 0.28).clamp(Vec3::splat(0.06), Vec3::splat(0.55));
+    for signs in [
+        Vec3::new(-1.0, -1.0, -1.0),
+        Vec3::new(1.0, -1.0, -1.0),
+        Vec3::new(-1.0, 1.0, -1.0),
+        Vec3::new(1.0, 1.0, -1.0),
+        Vec3::new(-1.0, -1.0, 1.0),
+        Vec3::new(1.0, -1.0, 1.0),
+        Vec3::new(-1.0, 1.0, 1.0),
+        Vec3::new(1.0, 1.0, 1.0),
+    ] {
+        let corner = center + rotation * (half * signs);
+        for axis in [Vec3::X, Vec3::Y, Vec3::Z] {
+            let length = lengths.dot(axis);
+            let direction = rotation * (axis * -signs.dot(axis));
+            gizmos.line(corner, corner + direction * length, color);
         }
     }
 }
diff --git a/crates/editor/src/viewport/visualizers.rs b/crates/editor/src/viewport/visualizers.rs
index 7361aec..754ac01 100644
--- a/crates/editor/src/viewport/visualizers.rs
+++ b/crates/editor/src/viewport/visualizers.rs
@@ -1,18 +1,20 @@
 //! Editor-side scene visualizers for authoring/runtime entities that have no mesh.
 
 use avian3d::prelude::ColliderConstructor;
+use bevy::ecs::system::SystemParam;
 use bevy::prelude::*;
 use shared::{
-    AuthoringLightKind, ColliderDesc, ColliderShapeDesc, LevelObject, LightDesc, ModelRef,
-    ObjectiveMarker, PhysicsBody, PlayerSpawn, PostProcessVolumeDesc, PrefabRef, ProjectSun,
-    RaytracingExcluded, TeamSpawn, TriggerVolume, WeaponSpawn,
+    AudioListenerDesc, AudioSourceDesc, AuthoringLightKind, ColliderDesc, ColliderShapeDesc,
+    LevelObject, LightDesc, ModelRef, ObjectiveMarker, PhysicsBody, PlayerSpawn,
+    PostProcessVolumeDesc, PrefabRef, ProjectSun, RaytracingExcluded, TeamSpawn, TriggerVolume,
+    WeaponSpawn,
 };
 use sim::tuning::{EYE_OFFSET_STAND, PLAYER_LENGTH, PLAYER_RADIUS};
 use sim::{Player, PlayerCamera};
 
 use crate::infra::EditorOnly;
 use crate::selection::SelectedEntity;
-use crate::state::scene_tools_active;
+use crate::state::{scene_tools_active, EditorMode, PlayPossession};
 use crate::viewport::{EditorViewportMode, ViewportDisplayMode};
 
 #[derive(Resource, Debug, Clone)]
@@ -22,6 +24,7 @@ pub struct EditorVisualizationSettings {
     pub show_actor_icon_actor: bool,
     pub show_actor_icon_mesh: bool,
     pub show_actor_icon_light: bool,
+    pub show_actor_icon_audio: bool,
     pub show_actor_icon_physics: bool,
     pub show_actor_icon_gameplay: bool,
     pub show_actor_icon_volume: bool,
@@ -29,7 +32,10 @@ pub struct EditorVisualizationSettings {
     pub show_actor_icon_debug: bool,
     pub show_colliders: bool,
     pub show_lights: bool,
+    pub show_audio: bool,
     pub show_spawns: bool,
+    pub show_gameplay: bool,
+    pub show_volumes: bool,
     pub show_prefab_model_anchors: bool,
     pub show_runtime: bool,
     pub pickable_proxies: bool,
@@ -43,6 +49,7 @@ impl Default for EditorVisualizationSettings {
             show_actor_icon_actor: true,
             show_actor_icon_mesh: true,
             show_actor_icon_light: true,
+            show_actor_icon_audio: true,
             show_actor_icon_physics: true,
             show_actor_icon_gameplay: true,
             show_actor_icon_volume: true,
@@ -50,7 +57,10 @@ impl Default for EditorVisualizationSettings {
             show_actor_icon_debug: true,
             show_colliders: true,
             show_lights: true,
+            show_audio: true,
             show_spawns: true,
+            show_gameplay: true,
+            show_volumes: true,
             show_prefab_model_anchors: true,
             show_runtime: true,
             pickable_proxies: true,
@@ -82,17 +92,39 @@ struct VisualizerProxyAssets {
     material: Handle<StandardMaterial>,
 }
 
+#[derive(SystemParam)]
+struct VisualizerTargetQueries<'w, 's> {
+    transforms: Query<'w, 's, &'static GlobalTransform>,
+    colliders: Query<
+        'w,
+        's,
+        Entity,
+        (
+            With<LevelObject>,
+            Or<(With<PhysicsBody>, With<ColliderDesc>)>,
+        ),
+    >,
+    lights: Query<'w, 's, Entity, (With<LevelObject>, With<LightDesc>)>,
+    spawns: Query<'w, 's, Entity, (With<LevelObject>, With<PlayerSpawn>)>,
+    prefabs: Query<'w, 's, Entity, (With<LevelObject>, With<PrefabRef>)>,
+    models: Query<'w, 's, Entity, (With<LevelObject>, With<ModelRef>)>,
+    players: Query<'w, 's, Entity, With<Player>>,
+    cameras: Query<'w, 's, Entity, With<PlayerCamera>>,
+    project_suns: Query<'w, 's, Entity, With<ProjectSun>>,
+}
+
 pub struct EditorVisualizersPlugin;
 
 impl Plugin for EditorVisualizersPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<EditorVisualizationSettings>()
             .add_systems(Startup, init_visualizer_proxy_assets)
-            .add_systems(Update, sync_visualizer_proxies.run_if(scene_tools_active))
+            .add_systems(Update, sync_visualizer_proxies)
             .add_systems(
                 Update,
                 (
                     draw_visualizers,
+                    draw_audio_visualizers,
                     draw_split_collider_visualizers,
                     draw_post_process_volume_gizmos,
                 )
@@ -103,6 +135,124 @@ impl Plugin for EditorVisualizersPlugin {
     }
 }
 
+fn draw_audio_visualizers(
+    viewport_mode: Res<EditorViewportMode>,
+    settings: Res<EditorVisualizationSettings>,
+    selected: Res<SelectedEntity>,
+    mut gizmos: Gizmos,
+    sources: Query<(Entity, &AudioSourceDesc, &GlobalTransform), With<LevelObject>>,
+    listeners: Query<(Entity, &AudioListenerDesc, &GlobalTransform), With<LevelObject>>,
+) {
+    if *viewport_mode == EditorViewportMode::Collider || !settings.enabled || !settings.show_audio {
+        return;
+    }
+    let Some(selected) = selected.0 else {
+        return;
+    };
+
+    if let Ok((_, source, global)) = sources.get(selected) {
+        draw_audio_source(&mut gizmos, global, source);
+    }
+    if let Ok((_, listener, global)) = listeners.get(selected) {
+        draw_audio_listener(&mut gizmos, global, listener);
+    }
+}
+
+fn draw_audio_source(gizmos: &mut Gizmos, global: &GlobalTransform, source: &AudioSourceDesc) {
+    let center = global.translation();
+    let (min_distance, max_distance) = normalized_audio_radii(
+        source.attenuation.min_distance,
+        source.attenuation.max_distance,
+    );
+    let blend = source.spatial_blend.clamp(0.0, 1.0);
+    let inner = Color::srgba(0.28, 0.92, 1.0, 0.9);
+    let outer = Color::srgba(0.22, 0.68, 1.0, 0.28 + blend * 0.32);
+
+    gizmos
+        .sphere(
+            Isometry3d::new(center, global.rotation()),
+            min_distance,
+            inner,
+        )
+        .resolution(28);
+    gizmos
+        .sphere(
+            Isometry3d::new(center, global.rotation()),
+            max_distance,
+            outer,
+        )
+        .resolution(36);
+}
+
+fn draw_audio_listener(
+    gizmos: &mut Gizmos,
+    global: &GlobalTransform,
+    listener: &AudioListenerDesc,
+) {
+    let geometry =
+        audio_listener_geometry(global.translation(), global.rotation(), listener.ear_gap);
+    let color = if listener.enabled {
+        Color::srgba(0.35, 1.0, 0.76, 1.0)
+    } else {
+        Color::srgba(0.55, 0.62, 0.66, 0.75)
+    };
+
+    gizmos.line(geometry.left_ear, geometry.right_ear, color);
+    for ear in [geometry.left_ear, geometry.right_ear] {
+        gizmos
+            .sphere(Isometry3d::from_translation(ear), 0.07, color)
+            .resolution(12);
+    }
+    gizmos.arrow(geometry.center, geometry.forward_end, color);
+    gizmos
+        .circle(
+            Isometry3d::new(geometry.center, global.rotation()),
+            geometry.head_radius,
+            color.with_alpha(0.55),
+        )
+        .resolution(24);
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+struct AudioListenerGeometry {
+    center: Vec3,
+    left_ear: Vec3,
+    right_ear: Vec3,
+    forward_end: Vec3,
+    head_radius: f32,
+}
+
+fn normalized_audio_radii(min_distance: f32, max_distance: f32) -> (f32, f32) {
+    let min_distance = if min_distance.is_finite() {
+        min_distance.max(0.05)
+    } else {
+        0.05
+    };
+    let max_distance = if max_distance.is_finite() {
+        max_distance.max(min_distance)
+    } else {
+        min_distance
+    };
+    (min_distance, max_distance)
+}
+
+fn audio_listener_geometry(center: Vec3, rotation: Quat, ear_gap: f32) -> AudioListenerGeometry {
+    let ear_gap = if ear_gap.is_finite() {
+        ear_gap.max(0.02)
+    } else {
+        0.02
+    };
+    let right = rotation * Vec3::X;
+    let forward = rotation * Vec3::NEG_Z;
+    AudioListenerGeometry {
+        center,
+        left_ear: center - right * ear_gap * 0.5,
+        right_ear: center + right * ear_gap * 0.5,
+        forward_end: center + forward * 0.85,
+        head_radius: (ear_gap * 0.65).max(0.14),
+    }
+}
+
 fn viewport_editor_overlays_visible(display: Res<ViewportDisplayMode>) -> bool {
     !display.clean_game_view
 }
@@ -125,73 +275,80 @@ fn init_visualizer_proxy_assets(
 
 #[allow(clippy::too_many_arguments)]
 fn sync_visualizer_proxies(
+    mode: Res<State<EditorMode>>,
+    possession: Res<PlayPossession>,
     viewport_mode: Res<EditorViewportMode>,
     display: Res<ViewportDisplayMode>,
     settings: Res<EditorVisualizationSettings>,
     assets: Res<VisualizerProxyAssets>,
     mut commands: Commands,
     mut proxies: Query<(Entity, &EditorVisualizerProxy, &mut Transform)>,
-    transforms: Query<&GlobalTransform>,
-    colliders: Query<
-        Entity,
-        (
-            With<LevelObject>,
-            Or<(With<PhysicsBody>, With<ColliderDesc>)>,
-        ),
-    >,
-    lights: Query<Entity, (With<LevelObject>, With<LightDesc>)>,
-    spawns: Query<Entity, (With<LevelObject>, With<PlayerSpawn>)>,
-    prefabs: Query<Entity, (With<LevelObject>, With<PrefabRef>)>,
-    models: Query<Entity, (With<LevelObject>, With<ModelRef>)>,
-    players: Query<Entity, With<Player>>,
-    cameras: Query<Entity, With<PlayerCamera>>,
-    project_suns: Query<Entity, With<ProjectSun>>,
+    targets: VisualizerTargetQueries,
 ) {
     let mut desired = std::collections::HashSet::new();
     let collider_mode = *viewport_mode == EditorViewportMode::Collider;
-    let proxies_active = !display.clean_game_view
+    let tools_active = *mode.get() == EditorMode::Editing
+        || (*mode.get() == EditorMode::Playing && *possession == PlayPossession::Ejected);
+    let proxies_active = tools_active
+        && !display.clean_game_view
         && settings.enabled
         && (settings.pickable_proxies || collider_mode);
 
     if proxies_active {
         if settings.show_colliders || collider_mode {
             desired.extend(
-                colliders
+                targets
+                    .colliders
                     .iter()
                     .map(|target| (target, VisualizerKind::Collider)),
             );
         }
         if settings.show_lights && !collider_mode {
-            desired.extend(lights.iter().map(|target| (target, VisualizerKind::Light)));
+            desired.extend(
+                targets
+                    .lights
+                    .iter()
+                    .map(|target| (target, VisualizerKind::Light)),
+            );
         }
         if settings.show_spawns && !collider_mode {
             desired.extend(
-                spawns
+                targets
+                    .spawns
                     .iter()
                     .map(|target| (target, VisualizerKind::PlayerSpawn)),
             );
         }
         if settings.show_prefab_model_anchors && !collider_mode {
             desired.extend(
-                prefabs
+                targets
+                    .prefabs
                     .iter()
                     .map(|target| (target, VisualizerKind::Prefab)),
             );
-            desired.extend(models.iter().map(|target| (target, VisualizerKind::Model)));
+            desired.extend(
+                targets
+                    .models
+                    .iter()
+                    .map(|target| (target, VisualizerKind::Model)),
+            );
         }
         if settings.show_runtime && !collider_mode {
             desired.extend(
-                players
+                targets
+                    .players
                     .iter()
                     .map(|target| (target, VisualizerKind::Player)),
             );
             desired.extend(
-                cameras
+                targets
+                    .cameras
                     .iter()
                     .map(|target| (target, VisualizerKind::Camera)),
             );
             desired.extend(
-                project_suns
+                targets
+                    .project_suns
                     .iter()
                     .map(|target| (target, VisualizerKind::ProjectSun)),
             );
@@ -204,15 +361,17 @@ fn sync_visualizer_proxies(
         .collect();
 
     for (entity, proxy, mut transform) in &mut proxies {
-        if !desired.contains(&(proxy.target, proxy.kind)) || transforms.get(proxy.target).is_err() {
+        if !desired.contains(&(proxy.target, proxy.kind))
+            || targets.transforms.get(proxy.target).is_err()
+        {
             commands.entity(entity).despawn();
-        } else if let Ok(global) = transforms.get(proxy.target) {
+        } else if let Ok(global) = targets.transforms.get(proxy.target) {
             transform.translation = global.translation();
         }
     }
 
     for (target, kind) in desired {
-        let Ok(global) = transforms.get(target) else {
+        let Ok(global) = targets.transforms.get(target) else {
             continue;
         };
         if existing.contains(&(target, kind)) {
@@ -339,41 +498,43 @@ fn draw_visualizers(
         }
     }
 
-    for (entity, trigger, global) in &triggers {
-        draw_oriented_box(
-            &mut gizmos,
-            global,
-            trigger.half_extents,
-            if selected.0 == Some(entity) {
-                Color::srgba(0.95, 0.35, 0.95, 0.85)
-            } else {
-                Color::srgba(0.9, 0.3, 0.9, 0.45)
-            },
-        );
-    }
-    for (entity, global) in &weapons {
-        draw_anchor(
-            &mut gizmos,
-            global,
-            selected.0 == Some(entity),
-            Color::srgb(1.0, 0.35, 0.2),
-        );
-    }
-    for (entity, global) in &teams {
-        draw_anchor(
-            &mut gizmos,
-            global,
-            selected.0 == Some(entity),
-            Color::srgb(0.2, 0.85, 0.35),
-        );
-    }
-    for (entity, global) in &objectives {
-        draw_anchor(
-            &mut gizmos,
-            global,
-            selected.0 == Some(entity),
-            Color::srgb(0.95, 0.85, 0.2),
-        );
+    if settings.show_gameplay && !collider_mode {
+        for (entity, trigger, global) in &triggers {
+            draw_oriented_box(
+                &mut gizmos,
+                global,
+                trigger.half_extents,
+                if selected.0 == Some(entity) {
+                    Color::srgba(1.0, 0.55, 0.95, 0.95)
+                } else {
+                    Color::srgba(0.9, 0.3, 0.9, 0.42)
+                },
+            );
+        }
+        for (entity, global) in &weapons {
+            draw_anchor(
+                &mut gizmos,
+                global,
+                selected.0 == Some(entity),
+                Color::srgb(1.0, 0.35, 0.2),
+            );
+        }
+        for (entity, global) in &teams {
+            draw_anchor(
+                &mut gizmos,
+                global,
+                selected.0 == Some(entity),
+                Color::srgb(0.2, 0.85, 0.35),
+            );
+        }
+        for (entity, global) in &objectives {
+            draw_anchor(
+                &mut gizmos,
+                global,
+                selected.0 == Some(entity),
+                Color::srgb(0.95, 0.85, 0.2),
+            );
+        }
     }
 }
 
@@ -413,7 +574,8 @@ fn draw_post_process_volume_gizmos(
     mut gizmos: Gizmos,
     volumes: Query<(Entity, &PostProcessVolumeDesc, &GlobalTransform), With<LevelObject>>,
 ) {
-    if *viewport_mode == EditorViewportMode::Collider || !settings.enabled {
+    if *viewport_mode == EditorViewportMode::Collider || !settings.enabled || !settings.show_volumes
+    {
         return;
     }
     for (entity, volume, global) in &volumes {
@@ -424,7 +586,7 @@ fn draw_post_process_volume_gizmos(
             global,
             volume.half_extents,
             if selected.0 == Some(entity) {
-                border.with_alpha(1.0)
+                Color::srgba(1.0, 0.76, 0.34, 1.0)
             } else {
                 border.with_alpha(0.55)
             },
@@ -566,12 +728,20 @@ fn draw_light(
             let up = global.up().as_vec3();
             let outer_deg = light.outer_angle_deg.max(light.inner_angle_deg);
             let radius = range * (outer_deg.to_radians() * 0.5).tan().max(0.15);
+            let inner_radius = range * (light.inner_angle_deg.to_radians() * 0.5).tan().max(0.08);
             for offset in [right, -right, up, -up] {
                 gizmos.line(center, end + offset * radius, color);
             }
             gizmos
                 .circle(Isometry3d::new(end, global.rotation()), radius, color)
                 .resolution(24);
+            gizmos
+                .circle(
+                    Isometry3d::new(end, global.rotation()),
+                    inner_radius,
+                    color.with_alpha(0.38),
+                )
+                .resolution(24);
             if emphasize {
                 gizmos
                     .sphere(
@@ -627,7 +797,7 @@ fn draw_spawn(gizmos: &mut Gizmos, global: &GlobalTransform, color: Color) {
 fn draw_anchor(gizmos: &mut Gizmos, global: &GlobalTransform, selected: bool, base: Color) {
     let center = global.translation();
     let color = if selected {
-        Color::srgba(1.0, 0.85, 1.0, 1.0)
+        Color::srgba(1.0, 0.76, 0.34, 1.0)
     } else {
         base.with_alpha(0.75)
     };
@@ -681,19 +851,34 @@ fn draw_camera_frustum(gizmos: &mut Gizmos, global: &GlobalTransform, color: Col
     let forward = global.forward().as_vec3();
     let right = global.right().as_vec3();
     let up = global.up().as_vec3();
-    let near = origin + forward * 0.8;
-    let half_w = 0.45;
-    let half_h = 0.28;
-    let corners = [
-        near + right * half_w + up * half_h,
-        near - right * half_w + up * half_h,
-        near - right * half_w - up * half_h,
-        near + right * half_w - up * half_h,
-    ];
-    for corner in corners {
-        gizmos.line(origin, corner, color);
+    let near_center = origin + forward * 0.55;
+    let far_center = origin + forward * 2.4;
+    let near = frustum_corners(near_center, right, up, 0.28, 0.17);
+    let far = frustum_corners(far_center, right, up, 1.1, 0.66);
+    for corner in near {
+        gizmos.line(origin, corner, color.with_alpha(0.72));
     }
-    gizmos.lineloop(corners, color);
+    gizmos.lineloop(near, color.with_alpha(0.72));
+    gizmos.lineloop(far, color);
+    for index in 0..4 {
+        gizmos.line(near[index], far[index], color);
+    }
+    gizmos.arrow(origin, origin + forward * 1.15, color.with_alpha(0.8));
+}
+
+fn frustum_corners(
+    center: Vec3,
+    right: Vec3,
+    up: Vec3,
+    half_width: f32,
+    half_height: f32,
+) -> [Vec3; 4] {
+    [
+        center + right * half_width + up * half_height,
+        center - right * half_width + up * half_height,
+        center - right * half_width - up * half_height,
+        center + right * half_width - up * half_height,
+    ]
 }
 
 fn draw_box(gizmos: &mut Gizmos, center: Vec3, rotation: Quat, half: Vec3, color: Color) {
@@ -798,3 +983,31 @@ fn box_edges() -> [(usize, usize); 12] {
         (3, 7),
     ]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn audio_radii_are_finite_positive_and_ordered() {
+        assert_eq!(normalized_audio_radii(2.0, 8.0), (2.0, 8.0));
+        assert_eq!(normalized_audio_radii(4.0, 1.0), (4.0, 4.0));
+        assert_eq!(
+            normalized_audio_radii(f32::NAN, f32::INFINITY),
+            (0.05, 0.05)
+        );
+    }
+
+    #[test]
+    fn listener_geometry_respects_rotation_and_ear_gap() {
+        let geometry = audio_listener_geometry(
+            Vec3::new(2.0, 3.0, 4.0),
+            Quat::from_rotation_y(std::f32::consts::FRAC_PI_2),
+            0.4,
+        );
+
+        assert!((geometry.left_ear.distance(geometry.right_ear) - 0.4).abs() < 1.0e-5);
+        assert!((geometry.forward_end - Vec3::new(1.15, 3.0, 4.0)).length() < 1.0e-5);
+        assert!(geometry.head_radius >= 0.14);
+    }
+}
diff --git a/crates/game/Cargo.toml b/crates/game/Cargo.toml
index 4cee388..48354ca 100644
--- a/crates/game/Cargo.toml
+++ b/crates/game/Cargo.toml
@@ -15,9 +15,13 @@ hot-reload = ["dep:hot-lib-reloader", "game_hot/dylib"]
 avian3d.workspace = true
 bevy.workspace = true
 bevy_ufbx.workspace = true
+cpal = "0.17.3"
 game_hot = { path = "../game_hot" }
 hot-lib-reloader = { version = "0.8.2", optional = true }
 protocol.workspace = true
+ron = "0.12"
+scene.workspace = true
+serde.workspace = true
 shared.workspace = true
 sim.workspace = true
 settings.workspace = true
diff --git a/crates/game/src/animation.rs b/crates/game/src/animation.rs
new file mode 100644
index 0000000..32c103a
--- /dev/null
+++ b/crates/game/src/animation.rs
@@ -0,0 +1,1434 @@
+//! Runtime adapter for scene-authored animation controllers.
+
+use std::collections::{HashMap, VecDeque};
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use bevy::animation::{
+    prelude::{
+        AnimationGraph, AnimationGraphHandle, AnimationNodeIndex, AnimationPlayer,
+        AnimationTransitions,
+    },
+    RepeatAnimation,
+};
+use bevy::gltf::GltfAssetLabel;
+use bevy::prelude::*;
+use bevy::world_serialization::WorldInstanceReady;
+use shared::{
+    animation_clip_source_index, asset_server_path, AnimationControllerDesc, AnimationEventDesc,
+    AnimationManifest, AnimationStateDesc, HydratedModelRoot, ANIMATION_ARTIFACT_DIR,
+};
+use sim::SimEnabled;
+
+const MAX_RUNTIME_DIAGNOSTICS: usize = 64;
+
+/// Gameplay request to transition one animated actor to a named authored state.
+#[derive(Message, Debug, Clone, PartialEq)]
+pub struct AnimationStateRequest {
+    pub actor: Entity,
+    pub state_id: String,
+    /// `None` uses the controller's authored default crossfade.
+    pub crossfade_seconds: Option<f32>,
+}
+
+impl AnimationStateRequest {
+    pub fn new(actor: Entity, state_id: impl Into<String>) -> Self {
+        Self {
+            actor,
+            state_id: state_id.into(),
+            crossfade_seconds: None,
+        }
+    }
+
+    pub fn with_crossfade(mut self, seconds: f32) -> Self {
+        self.crossfade_seconds = Some(seconds);
+        self
+    }
+}
+
+/// One bounded runtime failure suitable for editor diagnostics and automated tests.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AnimationRuntimeDiagnostic {
+    pub actor: Option<Entity>,
+    pub code: &'static str,
+    pub message: String,
+}
+
+/// Gameplay-facing notification emitted when authored playback crosses an imported event marker.
+#[derive(Message, Debug, Clone, PartialEq)]
+pub struct AnimationEventNotification {
+    pub actor: Entity,
+    pub state_id: String,
+    pub event_id: String,
+    pub time_seconds: f32,
+    pub payload: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+struct AnimationStateRuntimeMetadata {
+    duration_seconds: f32,
+    events: Vec<AnimationEventDesc>,
+}
+
+/// Runtime animation failures. Invalid requests never disturb the active state.
+#[derive(Resource, Debug, Default)]
+pub struct AnimationRuntimeDiagnostics {
+    entries: VecDeque<AnimationRuntimeDiagnostic>,
+}
+
+impl AnimationRuntimeDiagnostics {
+    pub fn entries(&self) -> impl Iterator<Item = &AnimationRuntimeDiagnostic> {
+        self.entries.iter()
+    }
+
+    pub fn latest(&self) -> Option<&AnimationRuntimeDiagnostic> {
+        self.entries.back()
+    }
+
+    fn push(&mut self, actor: Option<Entity>, code: &'static str, message: impl Into<String>) {
+        if self.entries.len() == MAX_RUNTIME_DIAGNOSTICS {
+            self.entries.pop_front();
+        }
+        let message = message.into();
+        warn!("Animation runtime [{code}]: {message}");
+        self.entries.push_back(AnimationRuntimeDiagnostic {
+            actor,
+            code,
+            message,
+        });
+    }
+}
+
+/// Transient graph and playback state derived from [`AnimationControllerDesc`].
+#[derive(Component, Debug, Clone)]
+pub struct AuthoredAnimationRuntime {
+    pub player: Entity,
+    pub graph: Handle<AnimationGraph>,
+    pub state_nodes: HashMap<String, AnimationNodeIndex>,
+    pub active_state: Option<String>,
+    desired_state: Option<String>,
+    requested_crossfade_seconds: Option<f32>,
+    paused_by_sim: bool,
+    applied_preview_revision: Option<u64>,
+    metadata_by_state: HashMap<String, AnimationStateRuntimeMetadata>,
+    last_event_time: Option<f32>,
+}
+
+/// Editor-only transient preview request consumed by the shared runtime adapter.
+#[derive(Debug, Clone, PartialEq)]
+pub struct AnimationPreviewRequest {
+    pub actor: Entity,
+    pub state_id: String,
+    pub seek_seconds: Option<f32>,
+    pub playing: bool,
+}
+
+#[derive(Resource, Debug, Default)]
+pub struct AnimationPreviewRuntime {
+    pub request: Option<AnimationPreviewRequest>,
+    revision: u64,
+}
+
+#[derive(Component, Clone)]
+struct SuspendedAnimationTransitions(AnimationTransitions);
+
+#[derive(Resource, Debug, Default)]
+struct PendingAnimationRequests(HashMap<Entity, (String, Option<f32>)>);
+
+/// Animation hydration, state transitions, preview, and PIE pause reconciliation.
+pub struct GameAnimationPlugin;
+
+impl Plugin for GameAnimationPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<AnimationRuntimeDiagnostics>()
+            .init_resource::<AnimationPreviewRuntime>()
+            .init_resource::<PendingAnimationRequests>()
+            .add_message::<AnimationStateRequest>()
+            .add_message::<AnimationEventNotification>()
+            .add_observer(attach_controller_when_model_ready)
+            .add_systems(
+                Update,
+                (
+                    reconcile_changed_controllers,
+                    process_animation_state_requests,
+                    sync_authored_animation_playback,
+                    cleanup_stale_animation_runtimes,
+                )
+                    .chain(),
+            );
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn attach_controller_when_model_ready(
+    ready: On<WorldInstanceReady>,
+    mut commands: Commands,
+    roots: Query<&HydratedModelRoot>,
+    controllers: Query<&AnimationControllerDesc>,
+    children: Query<&Children>,
+    players: Query<Entity, With<AnimationPlayer>>,
+    asset_server: Res<AssetServer>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+    mut diagnostics: ResMut<AnimationRuntimeDiagnostics>,
+    mut pending: ResMut<PendingAnimationRequests>,
+) {
+    let Ok(root) = roots.get(ready.entity) else {
+        return;
+    };
+    let Ok(controller) = controllers.get(root.owner) else {
+        return;
+    };
+    let Some(player) = find_animation_player(ready.entity, &children, &players) else {
+        diagnostics.push(
+            Some(root.owner),
+            "animation.player_missing",
+            "The hydrated model contains no AnimationPlayer. Verify that the selected glTF scene contains an animated hierarchy.",
+        );
+        return;
+    };
+
+    configure_runtime(
+        &mut commands,
+        root.owner,
+        player,
+        controller,
+        &asset_server,
+        &mut graphs,
+        &mut diagnostics,
+        pending.0.remove(&root.owner),
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+fn reconcile_changed_controllers(
+    mut commands: Commands,
+    controllers: Query<
+        (Entity, &AnimationControllerDesc),
+        Or<(
+            Added<AnimationControllerDesc>,
+            Changed<AnimationControllerDesc>,
+        )>,
+    >,
+    roots: Query<(Entity, &HydratedModelRoot)>,
+    children: Query<&Children>,
+    players: Query<Entity, With<AnimationPlayer>>,
+    asset_server: Res<AssetServer>,
+    mut graphs: ResMut<Assets<AnimationGraph>>,
+    mut diagnostics: ResMut<AnimationRuntimeDiagnostics>,
+    mut pending: ResMut<PendingAnimationRequests>,
+) {
+    for (actor, controller) in &controllers {
+        let Some((root_entity, _)) = roots.iter().find(|(_, root)| root.owner == actor) else {
+            continue;
+        };
+        let Some(player) = find_animation_player(root_entity, &children, &players) else {
+            continue;
+        };
+        configure_runtime(
+            &mut commands,
+            actor,
+            player,
+            controller,
+            &asset_server,
+            &mut graphs,
+            &mut diagnostics,
+            pending.0.remove(&actor),
+        );
+    }
+}
+
+fn find_animation_player(
+    root: Entity,
+    children: &Query<&Children>,
+    players: &Query<Entity, With<AnimationPlayer>>,
+) -> Option<Entity> {
+    children
+        .iter_descendants(root)
+        .find(|entity| players.get(*entity).is_ok())
+}
+
+#[allow(clippy::too_many_arguments)]
+fn configure_runtime(
+    commands: &mut Commands,
+    actor: Entity,
+    player: Entity,
+    controller: &AnimationControllerDesc,
+    asset_server: &AssetServer,
+    graphs: &mut Assets<AnimationGraph>,
+    diagnostics: &mut AnimationRuntimeDiagnostics,
+    pending: Option<(String, Option<f32>)>,
+) {
+    match build_animation_graph(controller, asset_server, graphs) {
+        Ok((graph, state_nodes, metadata_by_state)) => {
+            let (desired_state, requested_crossfade_seconds) = pending.unwrap_or_else(|| {
+                (
+                    controller.default_state.clone(),
+                    Some(controller.default_crossfade_seconds),
+                )
+            });
+            commands.entity(player).insert((
+                AnimationGraphHandle(graph.clone()),
+                AnimationTransitions::new(),
+            ));
+            commands
+                .entity(player)
+                .remove::<SuspendedAnimationTransitions>();
+            commands.entity(actor).insert(AuthoredAnimationRuntime {
+                player,
+                graph,
+                state_nodes,
+                active_state: None,
+                desired_state: (!desired_state.trim().is_empty()).then_some(desired_state),
+                requested_crossfade_seconds,
+                paused_by_sim: false,
+                applied_preview_revision: None,
+                metadata_by_state,
+                last_event_time: None,
+            });
+        }
+        Err(error) => {
+            diagnostics.push(Some(actor), "animation.graph_invalid", error);
+            clear_failed_runtime_configuration(commands, actor, player);
+        }
+    }
+}
+
+fn clear_failed_runtime_configuration(commands: &mut Commands, actor: Entity, player: Entity) {
+    commands.queue(move |world: &mut World| {
+        if let Some(mut animation_player) = world.get_mut::<AnimationPlayer>(player) {
+            animation_player.stop_all();
+        }
+        if let Ok(mut player_entity) = world.get_entity_mut(player) {
+            player_entity
+                .remove::<AnimationGraphHandle>()
+                .remove::<AnimationTransitions>()
+                .remove::<SuspendedAnimationTransitions>();
+        }
+        if let Ok(mut actor_entity) = world.get_entity_mut(actor) {
+            actor_entity.remove::<AuthoredAnimationRuntime>();
+        }
+        if let Some(mut preview) = world.get_resource_mut::<AnimationPreviewRuntime>() {
+            if preview
+                .request
+                .as_ref()
+                .is_some_and(|request| request.actor == actor)
+            {
+                preview.request = None;
+                preview.revision = preview.revision.wrapping_add(1);
+            }
+        }
+    });
+}
+
+fn build_animation_graph(
+    controller: &AnimationControllerDesc,
+    asset_server: &AssetServer,
+    graphs: &mut Assets<AnimationGraph>,
+) -> Result<
+    (
+        Handle<AnimationGraph>,
+        HashMap<String, AnimationNodeIndex>,
+        HashMap<String, AnimationStateRuntimeMetadata>,
+    ),
+    String,
+> {
+    let mut graph = AnimationGraph::new();
+    let mut state_nodes = HashMap::new();
+    let mut metadata_by_state = HashMap::new();
+    let assets_root = PathBuf::from(crate::launch::resolve_assets_directory());
+    let mut manifests = HashMap::new();
+
+    for state in &controller.states {
+        if state.id.trim().is_empty() {
+            return Err("Animation controller contains an empty state ID.".into());
+        }
+        if state_nodes.contains_key(&state.id) {
+            return Err(format!(
+                "Animation controller contains duplicate state ID `{}`.",
+                state.id
+            ));
+        }
+        if !state.speed.is_finite() || state.speed <= 0.0 {
+            return Err(format!(
+                "Animation state `{}` speed must be positive and finite.",
+                state.id
+            ));
+        }
+        let (index, source_path, metadata) =
+            resolve_animation_state_source(state, &assets_root, &mut manifests)?;
+        let path = asset_server_path(&source_path);
+        if !matches!(
+            std::path::Path::new(&path)
+                .extension()
+                .and_then(|extension| extension.to_str())
+                .map(|extension| extension.to_ascii_lowercase())
+                .as_deref(),
+            Some("gltf" | "glb")
+        ) {
+            return Err(format!(
+                "Animation state `{}` uses unsupported animated source `{source_path}`; animation v1 requires glTF/GLB.",
+                state.id
+            ));
+        }
+        let clip = asset_server.load(GltfAssetLabel::Animation(index).from_asset(path));
+        let node = graph.add_clip(clip, 1.0, graph.root);
+        state_nodes.insert(state.id.clone(), node);
+        metadata_by_state.insert(state.id.clone(), metadata);
+    }
+
+    if state_nodes.is_empty() {
+        return Err("Animation controller contains no states.".into());
+    }
+    Ok((graphs.add(graph), state_nodes, metadata_by_state))
+}
+
+fn resolve_animation_state_source(
+    state: &AnimationStateDesc,
+    assets_root: &Path,
+    manifests: &mut HashMap<String, AnimationManifest>,
+) -> Result<(usize, String, AnimationStateRuntimeMetadata), String> {
+    let index = animation_clip_source_index(&state.clip.sub_asset_id).ok_or_else(|| {
+        format!(
+            "Animation state `{}` has invalid clip sub-asset ID `{}`.",
+            state.id, state.clip.sub_asset_id
+        )
+    })?;
+    if state.clip.asset_id.trim().is_empty() {
+        return Err(format!(
+            "Animation state `{}` clip `{}` has no stable parent asset ID.",
+            state.id, state.clip.label
+        ));
+    }
+    if !manifests.contains_key(&state.clip.asset_id) {
+        let manifest = load_runtime_animation_manifest(assets_root, &state.clip.asset_id)?;
+        manifests.insert(state.clip.asset_id.clone(), manifest);
+    }
+    let manifest = manifests
+        .get(&state.clip.asset_id)
+        .expect("animation manifest was inserted above");
+    if manifest.asset_id != state.clip.asset_id {
+        return Err(format!(
+            "Animation manifest `{}` belongs to asset `{}` instead of `{}`.",
+            runtime_animation_manifest_path(assets_root, &state.clip.asset_id).display(),
+            manifest.asset_id,
+            state.clip.asset_id
+        ));
+    }
+    if !manifest.runtime_supported {
+        return Err(format!(
+            "Animation state `{}` uses a manifest that is not supported by the runtime; animation v1 requires glTF/GLB.",
+            state.id
+        ));
+    }
+    let clip = manifest
+        .clips
+        .iter()
+        .find(|clip| clip.id == state.clip.sub_asset_id)
+        .ok_or_else(|| {
+            format!(
+                "Animation state `{}` clip `{}` is missing from the generated manifest; reimport or reassign it.",
+                state.id, state.clip.sub_asset_id
+            )
+        })?;
+    if clip.source_index != index {
+        return Err(format!(
+            "Animation state `{}` clip ID encodes source index {index}, but the manifest records {}.",
+            state.id, clip.source_index
+        ));
+    }
+    if manifest.source.path.trim().is_empty() {
+        return Err(format!(
+            "Animation state `{}` manifest has no current source path.",
+            state.id
+        ));
+    }
+    Ok((
+        index,
+        manifest.source.path.clone(),
+        AnimationStateRuntimeMetadata {
+            duration_seconds: clip.duration_seconds,
+            events: clip.events.clone(),
+        },
+    ))
+}
+
+fn runtime_animation_manifest_path(assets_root: &Path, asset_id: &str) -> PathBuf {
+    let relative_dir = ANIMATION_ARTIFACT_DIR
+        .strip_prefix("assets/")
+        .unwrap_or(ANIMATION_ARTIFACT_DIR);
+    assets_root
+        .join(relative_dir)
+        .join(format!("{asset_id}.animation.ron"))
+}
+
+fn load_runtime_animation_manifest(
+    assets_root: &Path,
+    asset_id: &str,
+) -> Result<AnimationManifest, String> {
+    let path = runtime_animation_manifest_path(assets_root, asset_id);
+    let text = std::fs::read_to_string(&path)
+        .map_err(|error| format!("could not read {}: {error}", path.display()))?;
+    ron::from_str(&text).map_err(|error| format!("could not parse {}: {error}", path.display()))
+}
+
+fn process_animation_state_requests(
+    mut requests: MessageReader<AnimationStateRequest>,
+    controllers: Query<&AnimationControllerDesc>,
+    mut runtimes: Query<&mut AuthoredAnimationRuntime>,
+    mut pending: ResMut<PendingAnimationRequests>,
+    mut diagnostics: ResMut<AnimationRuntimeDiagnostics>,
+) {
+    for request in requests.read() {
+        let Ok(controller) = controllers.get(request.actor) else {
+            diagnostics.push(
+                Some(request.actor),
+                "animation.controller_missing",
+                "Animation state request targeted an actor without AnimationControllerDesc.",
+            );
+            continue;
+        };
+        if controller.state(&request.state_id).is_none() {
+            diagnostics.push(
+                Some(request.actor),
+                "animation.state_missing",
+                format!(
+                    "Animation controller has no state `{}`; the active state was preserved.",
+                    request.state_id
+                ),
+            );
+            continue;
+        }
+        if request
+            .crossfade_seconds
+            .is_some_and(|seconds| !seconds.is_finite() || seconds < 0.0)
+        {
+            diagnostics.push(
+                Some(request.actor),
+                "animation.crossfade_invalid",
+                "Animation state request crossfade must be finite and nonnegative; the active state was preserved.",
+            );
+            continue;
+        }
+
+        pending.0.insert(
+            request.actor,
+            (request.state_id.clone(), request.crossfade_seconds),
+        );
+        if let Ok(mut runtime) = runtimes.get_mut(request.actor) {
+            runtime.desired_state = Some(request.state_id.clone());
+            runtime.requested_crossfade_seconds = request.crossfade_seconds;
+            pending.0.remove(&request.actor);
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn sync_authored_animation_playback(
+    mut commands: Commands,
+    sim_enabled: Res<SimEnabled>,
+    preview: Res<AnimationPreviewRuntime>,
+    controllers: Query<&AnimationControllerDesc>,
+    mut runtimes: Query<(Entity, &mut AuthoredAnimationRuntime)>,
+    mut players: Query<(
+        &mut AnimationPlayer,
+        Option<&mut AnimationTransitions>,
+        Option<&SuspendedAnimationTransitions>,
+    )>,
+    mut diagnostics: ResMut<AnimationRuntimeDiagnostics>,
+    mut event_notifications: MessageWriter<AnimationEventNotification>,
+) {
+    for (actor, mut runtime) in &mut runtimes {
+        let Ok(controller) = controllers.get(actor) else {
+            continue;
+        };
+        let Ok((mut player, mut live_transitions, suspended_transitions)) =
+            players.get_mut(runtime.player)
+        else {
+            continue;
+        };
+        let preview_request = preview
+            .request
+            .as_ref()
+            .filter(|request| request.actor == actor);
+        let should_run = sim_enabled.0 || preview_request.is_some();
+        if !should_run {
+            if runtime.active_state.is_some() {
+                player.pause_all();
+                runtime.paused_by_sim = true;
+                if let Some(transitions) = live_transitions.as_deref() {
+                    commands
+                        .entity(runtime.player)
+                        .remove::<AnimationTransitions>()
+                        .insert(SuspendedAnimationTransitions(transitions.clone()));
+                }
+            }
+            continue;
+        }
+
+        let detached_transitions = live_transitions.is_none();
+        let mut restored_transitions = detached_transitions.then(|| {
+            suspended_transitions
+                .map(|transitions| transitions.0.clone())
+                .unwrap_or_default()
+        });
+
+        let desired_state = preview_request
+            .map(|request| request.state_id.as_str())
+            .or(runtime.desired_state.as_deref())
+            .or((!controller.default_state.trim().is_empty())
+                .then_some(controller.default_state.as_str()))
+            .map(str::to_owned);
+        let Some(desired_state) = desired_state else {
+            continue;
+        };
+        let Some(state) = controller.state(&desired_state) else {
+            diagnostics.push(
+                Some(actor),
+                "animation.state_missing",
+                format!("Animation controller has no state `{desired_state}`."),
+            );
+            runtime.desired_state = None;
+            continue;
+        };
+        let Some(&node) = runtime.state_nodes.get(&desired_state) else {
+            diagnostics.push(
+                Some(actor),
+                "animation.state_unhydrated",
+                format!("Animation state `{desired_state}` has no hydrated graph node."),
+            );
+            continue;
+        };
+
+        if runtime.active_state.as_deref() != Some(desired_state.as_str()) {
+            let crossfade = if preview_request.is_some() {
+                0.0
+            } else {
+                runtime
+                    .requested_crossfade_seconds
+                    .take()
+                    .unwrap_or(controller.default_crossfade_seconds)
+            };
+            let transitions = live_transitions
+                .as_deref_mut()
+                .or(restored_transitions.as_mut())
+                .expect("detached transitions are restored locally");
+            let active = play_with_crossfade(transitions, &mut player, node, crossfade);
+            configure_active_animation(active, state);
+            runtime.active_state = Some(desired_state);
+            runtime.paused_by_sim = false;
+            runtime.last_event_time = None;
+        }
+
+        if let Some(request) = preview_request {
+            if runtime.applied_preview_revision != Some(preview.revision) {
+                if let Some(seek_seconds) = request.seek_seconds {
+                    if seek_seconds.is_finite() {
+                        if let Some(active) = player.animation_mut(node) {
+                            active.set_seek_time(clamp_seek_to_state(seek_seconds, state));
+                        }
+                    } else {
+                        diagnostics.push(
+                            Some(actor),
+                            "animation.preview_seek_invalid",
+                            "Animation preview seek must be finite.",
+                        );
+                    }
+                }
+                runtime.applied_preview_revision = Some(preview.revision);
+            }
+        } else {
+            runtime.applied_preview_revision = None;
+        }
+
+        let should_advance = preview_request
+            .map(|request| request.playing)
+            .unwrap_or(sim_enabled.0);
+        if should_advance {
+            player.resume_all();
+            if preview_request.is_none() {
+                if let (Some(metadata), Some(current)) = (
+                    runtime.metadata_by_state.get(&state.id),
+                    player.animation(node).map(|active| active.seek_time()),
+                ) {
+                    emit_crossed_animation_events(
+                        &mut event_notifications,
+                        actor,
+                        state,
+                        metadata,
+                        runtime.last_event_time,
+                        current,
+                    );
+                }
+            }
+            enforce_playback_range(&mut player, node, state);
+            runtime.last_event_time = player.animation(node).map(|active| active.seek_time());
+            runtime.paused_by_sim = false;
+            if let Some(transitions) = restored_transitions.take() {
+                commands
+                    .entity(runtime.player)
+                    .remove::<SuspendedAnimationTransitions>()
+                    .insert(transitions);
+            } else if live_transitions.is_some() && suspended_transitions.is_some() {
+                commands
+                    .entity(runtime.player)
+                    .remove::<SuspendedAnimationTransitions>();
+            }
+        } else {
+            enforce_playback_range(&mut player, node, state);
+            runtime.last_event_time = player.animation(node).map(|active| active.seek_time());
+            player.pause_all();
+            runtime.paused_by_sim = true;
+            let transitions = live_transitions
+                .as_deref()
+                .cloned()
+                .or(restored_transitions.take())
+                .unwrap_or_default();
+            commands
+                .entity(runtime.player)
+                .remove::<AnimationTransitions>()
+                .insert(SuspendedAnimationTransitions(transitions));
+        }
+    }
+}
+
+fn play_with_crossfade<'a>(
+    transitions: &mut AnimationTransitions,
+    player: &'a mut AnimationPlayer,
+    node: AnimationNodeIndex,
+    crossfade_seconds: f32,
+) -> &'a mut bevy::animation::ActiveAnimation {
+    let crossfade_seconds = if crossfade_seconds.is_finite() {
+        crossfade_seconds.max(0.0)
+    } else {
+        0.0
+    };
+    if crossfade_seconds <= f32::EPSILON {
+        player.stop_all();
+        *transitions = AnimationTransitions::new();
+        return transitions.play(player, node, Duration::ZERO);
+    }
+    if let Some(active) = transitions
+        .get_main_animation()
+        .and_then(|main_animation| player.animation_mut(main_animation))
+    {
+        active.resume();
+    }
+    transitions.play(player, node, Duration::from_secs_f32(crossfade_seconds))
+}
+
+fn configure_active_animation(
+    active: &mut bevy::animation::ActiveAnimation,
+    state: &AnimationStateDesc,
+) {
+    active
+        .set_speed(state.speed)
+        .set_seek_time(state.range.start_seconds.max(0.0));
+    if state.looping
+        && state.range.start_seconds <= f32::EPSILON
+        && state.range.end_seconds.is_none()
+    {
+        active.repeat();
+    } else {
+        active.set_repeat(RepeatAnimation::Never);
+    }
+}
+
+fn clamp_seek_to_state(seconds: f32, state: &AnimationStateDesc) -> f32 {
+    let start = state.range.start_seconds.max(0.0);
+    let end = state.range.end_seconds.unwrap_or(f32::MAX).max(start);
+    seconds.clamp(start, end)
+}
+
+fn enforce_playback_range(
+    player: &mut AnimationPlayer,
+    node: AnimationNodeIndex,
+    state: &AnimationStateDesc,
+) {
+    let Some(active) = player.animation_mut(node) else {
+        return;
+    };
+    let start = state.range.start_seconds.max(0.0);
+    if let Some(end) = state.range.end_seconds {
+        let end = end.max(start);
+        if active.seek_time() >= end {
+            if state.looping {
+                active.set_seek_time(start).resume();
+            } else {
+                active.set_seek_time(end).pause();
+            }
+        }
+    } else if state.looping && start > f32::EPSILON && active.just_completed() {
+        active.set_seek_time(start).resume();
+    }
+}
+
+fn emit_crossed_animation_events(
+    writer: &mut MessageWriter<AnimationEventNotification>,
+    actor: Entity,
+    state: &AnimationStateDesc,
+    metadata: &AnimationStateRuntimeMetadata,
+    previous: Option<f32>,
+    current: f32,
+) {
+    for event in crossed_animation_events(state, metadata, previous, current) {
+        writer.write(AnimationEventNotification {
+            actor,
+            state_id: state.id.clone(),
+            event_id: event.id.clone(),
+            time_seconds: event.time_seconds,
+            payload: event.payload.clone(),
+        });
+    }
+}
+
+fn crossed_animation_events<'a>(
+    state: &AnimationStateDesc,
+    metadata: &'a AnimationStateRuntimeMetadata,
+    previous: Option<f32>,
+    current: f32,
+) -> Vec<&'a AnimationEventDesc> {
+    if metadata.events.is_empty() || !current.is_finite() {
+        return Vec::new();
+    }
+    let start = state.range.start_seconds.max(0.0);
+    let end = state
+        .range
+        .end_seconds
+        .unwrap_or(metadata.duration_seconds)
+        .max(start);
+    let current = current.clamp(start, end);
+    let previous = previous
+        .unwrap_or(start - 0.000_001)
+        .clamp(start - 0.000_001, end);
+    let in_range = |event: &&AnimationEventDesc| {
+        event.time_seconds.is_finite() && event.time_seconds >= start && event.time_seconds <= end
+    };
+    if current >= previous {
+        return metadata
+            .events
+            .iter()
+            .filter(in_range)
+            .filter(|event| event.time_seconds > previous && event.time_seconds <= current)
+            .collect();
+    }
+    if !state.looping {
+        return Vec::new();
+    }
+    let mut crossed = metadata
+        .events
+        .iter()
+        .filter(in_range)
+        .filter(|event| event.time_seconds > previous)
+        .collect::<Vec<_>>();
+    crossed.extend(
+        metadata
+            .events
+            .iter()
+            .filter(in_range)
+            .filter(|event| event.time_seconds <= current),
+    );
+    crossed
+}
+
+fn cleanup_stale_animation_runtimes(
+    mut commands: Commands,
+    controllers: Query<(), With<AnimationControllerDesc>>,
+    runtimes: Query<(Entity, &AuthoredAnimationRuntime)>,
+    mut players: Query<&mut AnimationPlayer>,
+) {
+    for (actor, runtime) in &runtimes {
+        if controllers.get(actor).is_ok() && players.get(runtime.player).is_ok() {
+            continue;
+        }
+        if let Ok(mut player) = players.get_mut(runtime.player) {
+            player.stop_all();
+            commands
+                .entity(runtime.player)
+                .remove::<SuspendedAnimationTransitions>();
+        }
+        commands.entity(actor).remove::<AuthoredAnimationRuntime>();
+    }
+}
+
+/// Enqueues a validated gameplay state transition.
+pub fn request_animation_state(
+    world: &mut World,
+    request: AnimationStateRequest,
+) -> Result<(), String> {
+    let Some(controller) = world.get::<AnimationControllerDesc>(request.actor) else {
+        return Err("actor has no AnimationControllerDesc".into());
+    };
+    if controller.state(&request.state_id).is_none() {
+        return Err(format!(
+            "animation state `{}` does not exist",
+            request.state_id
+        ));
+    }
+    if request
+        .crossfade_seconds
+        .is_some_and(|seconds| !seconds.is_finite() || seconds < 0.0)
+    {
+        return Err("animation crossfade must be finite and nonnegative".into());
+    }
+    world.write_message(request);
+    Ok(())
+}
+
+/// Starts or scrubs a non-dirty editor preview through the runtime adapter.
+pub fn set_animation_preview(
+    world: &mut World,
+    request: AnimationPreviewRequest,
+) -> Result<(), String> {
+    let Some(controller) = world.get::<AnimationControllerDesc>(request.actor) else {
+        return Err("actor has no AnimationControllerDesc".into());
+    };
+    if controller.state(&request.state_id).is_none() {
+        return Err(format!(
+            "animation state `{}` does not exist",
+            request.state_id
+        ));
+    }
+    if request
+        .seek_seconds
+        .is_some_and(|seconds| !seconds.is_finite())
+    {
+        return Err("animation preview seek must be finite".into());
+    }
+    let mut preview = world.resource_mut::<AnimationPreviewRuntime>();
+    preview.revision = preview.revision.wrapping_add(1);
+    preview.request = Some(request);
+    Ok(())
+}
+
+/// Stops the active editor preview without changing authored data or history.
+pub fn stop_animation_preview(world: &mut World) {
+    let actor = {
+        let mut preview = world.resource_mut::<AnimationPreviewRuntime>();
+        let actor = preview.request.take().map(|request| request.actor);
+        preview.revision = preview.revision.wrapping_add(1);
+        actor
+    };
+    let Some(actor) = actor else {
+        return;
+    };
+    let player = world
+        .get::<AuthoredAnimationRuntime>(actor)
+        .map(|runtime| runtime.player);
+    if let Some(player) = player {
+        if let Some(mut animation_player) = world.get_mut::<AnimationPlayer>(player) {
+            animation_player.stop_all();
+        }
+    }
+    if let Some(mut runtime) = world.get_mut::<AuthoredAnimationRuntime>(actor) {
+        runtime.active_state = None;
+        runtime.paused_by_sim = false;
+        runtime.applied_preview_revision = None;
+        runtime.last_event_time = None;
+    }
+}
+
+/// Clears transient animation playback at an editor/PIE mode boundary while retaining graphs.
+pub fn reset_authored_animation_runtime(world: &mut World) {
+    {
+        let mut preview = world.resource_mut::<AnimationPreviewRuntime>();
+        preview.request = None;
+        preview.revision = preview.revision.wrapping_add(1);
+    }
+    let entries: Vec<(Entity, Entity)> = world
+        .query::<(Entity, &AuthoredAnimationRuntime)>()
+        .iter(world)
+        .map(|(actor, runtime)| (actor, runtime.player))
+        .collect();
+    for (actor, player) in entries {
+        if let Some(mut animation_player) = world.get_mut::<AnimationPlayer>(player) {
+            animation_player.stop_all();
+        }
+        if let Some(mut runtime) = world.get_mut::<AuthoredAnimationRuntime>(actor) {
+            runtime.active_state = None;
+            runtime.desired_state = None;
+            runtime.requested_crossfade_seconds = None;
+            runtime.paused_by_sim = false;
+            runtime.applied_preview_revision = None;
+            runtime.last_event_time = None;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::{AssetApp, AssetPlugin};
+    use shared::{
+        AnimationClipRecord, AnimationManifestSource, AnimationPlaybackRange,
+        AnimationSourceFingerprint, EditorAssetRef, ANIMATION_MANIFEST_SCHEMA_VERSION,
+    };
+
+    fn state(id: &str, index: usize) -> AnimationStateDesc {
+        AnimationStateDesc {
+            id: id.into(),
+            label: id.into(),
+            clip: EditorAssetRef::new("model-id", format!("animation:clip:{index}:{id}"), id)
+                .with_source_path("assets/models/animated.glb"),
+            looping: true,
+            speed: 1.25,
+            range: AnimationPlaybackRange {
+                start_seconds: 0.2,
+                end_seconds: Some(0.8),
+            },
+        }
+    }
+
+    fn runtime_test_app(sim_enabled: bool) -> (App, Entity, Entity, AnimationNodeIndex) {
+        let mut app = App::new();
+        app.insert_resource(SimEnabled(sim_enabled))
+            .init_resource::<AnimationPreviewRuntime>()
+            .init_resource::<AnimationRuntimeDiagnostics>()
+            .add_message::<AnimationEventNotification>()
+            .add_systems(Update, sync_authored_animation_playback);
+
+        let idle_node = AnimationNodeIndex::new(0);
+        let run_node = AnimationNodeIndex::new(1);
+        let player = app
+            .world_mut()
+            .spawn((AnimationPlayer::default(), AnimationTransitions::new()))
+            .id();
+        let actor = app
+            .world_mut()
+            .spawn(AnimationControllerDesc {
+                states: vec![state("idle", 0), state("run", 1)],
+                default_state: "idle".into(),
+                default_crossfade_seconds: 0.25,
+                ..Default::default()
+            })
+            .id();
+        app.world_mut()
+            .entity_mut(actor)
+            .insert(AuthoredAnimationRuntime {
+                player,
+                graph: Handle::default(),
+                state_nodes: HashMap::from([("idle".into(), idle_node), ("run".into(), run_node)]),
+                active_state: None,
+                desired_state: Some("idle".into()),
+                requested_crossfade_seconds: Some(0.25),
+                paused_by_sim: false,
+                applied_preview_revision: None,
+                metadata_by_state: HashMap::from([
+                    (
+                        "idle".into(),
+                        AnimationStateRuntimeMetadata {
+                            duration_seconds: 1.0,
+                            events: Vec::new(),
+                        },
+                    ),
+                    (
+                        "run".into(),
+                        AnimationStateRuntimeMetadata {
+                            duration_seconds: 1.0,
+                            events: Vec::new(),
+                        },
+                    ),
+                ]),
+                last_event_time: None,
+            });
+        (app, actor, player, run_node)
+    }
+
+    #[test]
+    fn seek_is_clamped_to_authored_range() {
+        let state = state("idle", 0);
+        assert_eq!(clamp_seek_to_state(-1.0, &state), 0.2);
+        assert_eq!(clamp_seek_to_state(0.5, &state), 0.5);
+        assert_eq!(clamp_seek_to_state(4.0, &state), 0.8);
+    }
+
+    #[test]
+    fn request_constructor_preserves_optional_crossfade() {
+        let actor = Entity::from_bits(42);
+        let request = AnimationStateRequest::new(actor, "run").with_crossfade(0.35);
+        assert_eq!(request.actor, actor);
+        assert_eq!(request.state_id, "run");
+        assert_eq!(request.crossfade_seconds, Some(0.35));
+    }
+
+    #[test]
+    fn event_crossings_follow_playback_order_and_loop_range() {
+        let state = state("run", 1);
+        let metadata = AnimationStateRuntimeMetadata {
+            duration_seconds: 1.0,
+            events: vec![
+                AnimationEventDesc {
+                    id: "left".into(),
+                    time_seconds: 0.25,
+                    payload: None,
+                },
+                AnimationEventDesc {
+                    id: "right".into(),
+                    time_seconds: 0.75,
+                    payload: Some("foot".into()),
+                },
+            ],
+        };
+
+        let first = crossed_animation_events(&state, &metadata, None, 0.5)
+            .into_iter()
+            .map(|event| event.id.as_str())
+            .collect::<Vec<_>>();
+        let wrapped = crossed_animation_events(&state, &metadata, Some(0.7), 0.3)
+            .into_iter()
+            .map(|event| event.id.as_str())
+            .collect::<Vec<_>>();
+
+        assert_eq!(first, vec!["left"]);
+        assert_eq!(wrapped, vec!["right", "left"]);
+    }
+
+    #[test]
+    fn runtime_source_resolution_uses_stable_manifest_after_move() {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-animation-runtime-{}",
+            std::process::id()
+        ));
+        let mut state = state("idle", 0);
+        state.clip.source_path = Some("assets/models/stale.glb".into());
+        let manifest = AnimationManifest {
+            schema_version: ANIMATION_MANIFEST_SCHEMA_VERSION,
+            asset_id: state.clip.asset_id.clone(),
+            label: "Moved Model".into(),
+            source: AnimationManifestSource {
+                path: "assets/models/relocated.glb".into(),
+                format: "glb".into(),
+                fingerprint: AnimationSourceFingerprint {
+                    byte_len: 1,
+                    modified_unix_secs: 0,
+                    content_hash: "fixture".into(),
+                },
+                dependencies: Vec::new(),
+            },
+            runtime_supported: true,
+            skeletons: Vec::new(),
+            clips: vec![AnimationClipRecord {
+                id: state.clip.sub_asset_id.clone(),
+                label: state.clip.label.clone(),
+                source_index: 0,
+                duration_seconds: 1.0,
+                target_skeleton_signature: None,
+                events: Vec::new(),
+            }],
+            diagnostics: Vec::new(),
+        };
+        let path = runtime_animation_manifest_path(&root, &state.clip.asset_id);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(
+            &path,
+            ron::ser::to_string_pretty(&manifest, ron::ser::PrettyConfig::default()).unwrap(),
+        )
+        .unwrap();
+
+        let (index, source_path, metadata) =
+            resolve_animation_state_source(&state, &root, &mut HashMap::new()).unwrap();
+
+        assert_eq!(index, 0);
+        assert_eq!(source_path, "assets/models/relocated.glb");
+        assert_eq!(metadata.duration_seconds, 1.0);
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn failed_runtime_reconfiguration_stops_and_clears_stale_playback() {
+        let mut app = App::new();
+        app.add_plugins((MinimalPlugins, AssetPlugin::default()))
+            .init_asset::<AnimationGraph>()
+            .insert_resource(SimEnabled(true))
+            .add_plugins(GameAnimationPlugin);
+
+        let actor = app.world_mut().spawn_empty().id();
+        let root = app
+            .world_mut()
+            .spawn((HydratedModelRoot { owner: actor }, ChildOf(actor)))
+            .id();
+        let stale_node = AnimationNodeIndex::new(0);
+        let mut animation_player = AnimationPlayer::default();
+        animation_player.start(stale_node);
+        let player = app
+            .world_mut()
+            .spawn((
+                animation_player,
+                AnimationGraphHandle::default(),
+                AnimationTransitions::new(),
+                ChildOf(root),
+            ))
+            .id();
+        app.world_mut().entity_mut(actor).insert((
+            AnimationControllerDesc::default(),
+            AuthoredAnimationRuntime {
+                player,
+                graph: Handle::default(),
+                state_nodes: HashMap::from([("stale".into(), stale_node)]),
+                active_state: Some("stale".into()),
+                desired_state: Some("stale".into()),
+                requested_crossfade_seconds: None,
+                paused_by_sim: false,
+                applied_preview_revision: None,
+                metadata_by_state: HashMap::new(),
+                last_event_time: None,
+            },
+        ));
+        app.world_mut()
+            .resource_mut::<AnimationPreviewRuntime>()
+            .request = Some(AnimationPreviewRequest {
+            actor,
+            state_id: "stale".into(),
+            seek_seconds: None,
+            playing: true,
+        });
+
+        app.update();
+
+        assert!(app.world().get::<AuthoredAnimationRuntime>(actor).is_none());
+        assert!(app.world().get::<AnimationGraphHandle>(player).is_none());
+        assert!(app.world().get::<AnimationTransitions>(player).is_none());
+        assert!(app
+            .world()
+            .get::<SuspendedAnimationTransitions>(player)
+            .is_none());
+        assert!(app
+            .world()
+            .get::<AnimationPlayer>(player)
+            .is_some_and(|player| player.playing_animations().next().is_none()));
+        assert!(app
+            .world()
+            .resource::<AnimationPreviewRuntime>()
+            .request
+            .is_none());
+        assert_eq!(
+            app.world()
+                .resource::<AnimationRuntimeDiagnostics>()
+                .latest()
+                .map(|diagnostic| diagnostic.code),
+            Some("animation.graph_invalid")
+        );
+    }
+
+    #[test]
+    fn zero_crossfade_discards_the_old_animation_immediately() {
+        let old_node = AnimationNodeIndex::new(0);
+        let new_node = AnimationNodeIndex::new(1);
+        let mut player = AnimationPlayer::default();
+        let mut transitions = AnimationTransitions::new();
+        transitions.play(&mut player, old_node, Duration::ZERO);
+
+        play_with_crossfade(&mut transitions, &mut player, new_node, 0.0);
+
+        assert!(!player.is_playing_animation(old_node));
+        assert!(player.is_playing_animation(new_node));
+        assert_eq!(transitions.get_main_animation(), Some(new_node));
+    }
+
+    #[test]
+    fn crossfade_resumes_a_main_animation_paused_by_simulation() {
+        let old_node = AnimationNodeIndex::new(0);
+        let new_node = AnimationNodeIndex::new(1);
+        let mut player = AnimationPlayer::default();
+        let mut transitions = AnimationTransitions::new();
+        transitions.play(&mut player, old_node, Duration::ZERO);
+        player.pause_all();
+
+        play_with_crossfade(&mut transitions, &mut player, new_node, 0.5);
+
+        assert!(!player
+            .animation(old_node)
+            .expect("old animation remains active during the fade")
+            .is_paused());
+        assert!(player.is_playing_animation(new_node));
+        assert_eq!(transitions.get_main_animation(), Some(new_node));
+    }
+
+    #[test]
+    fn playing_preview_applies_seek_only_once() {
+        let (mut app, actor, player, _) = runtime_test_app(false);
+        set_animation_preview(
+            app.world_mut(),
+            AnimationPreviewRequest {
+                actor,
+                state_id: "idle".into(),
+                seek_seconds: Some(0.5),
+                playing: true,
+            },
+        )
+        .unwrap();
+
+        app.update();
+        let idle_node = AnimationNodeIndex::new(0);
+        assert_eq!(
+            app.world()
+                .get::<AnimationPlayer>(player)
+                .unwrap()
+                .animation(idle_node)
+                .unwrap()
+                .seek_time(),
+            0.5
+        );
+
+        app.world_mut()
+            .get_mut::<AnimationPlayer>(player)
+            .unwrap()
+            .animation_mut(idle_node)
+            .unwrap()
+            .set_seek_time(0.65);
+        app.update();
+
+        assert_eq!(
+            app.world()
+                .get::<AnimationPlayer>(player)
+                .unwrap()
+                .animation(idle_node)
+                .unwrap()
+                .seek_time(),
+            0.65
+        );
+    }
+
+    #[test]
+    fn simulation_pause_suspends_and_restores_crossfade_state() {
+        let (mut app, actor, player, run_node) = runtime_test_app(true);
+        app.update();
+        {
+            let mut runtime = app
+                .world_mut()
+                .get_mut::<AuthoredAnimationRuntime>(actor)
+                .unwrap();
+            runtime.desired_state = Some("run".into());
+            runtime.requested_crossfade_seconds = Some(1.0);
+        }
+        app.update();
+        assert!(app
+            .world()
+            .get::<AnimationPlayer>(player)
+            .unwrap()
+            .is_playing_animation(run_node));
+
+        app.world_mut().resource_mut::<SimEnabled>().0 = false;
+        app.update();
+        assert!(app.world().get::<AnimationTransitions>(player).is_none());
+        assert!(app
+            .world()
+            .get::<SuspendedAnimationTransitions>(player)
+            .is_some());
+        assert!(app
+            .world()
+            .get::<AnimationPlayer>(player)
+            .unwrap()
+            .all_paused());
+
+        app.world_mut().resource_mut::<SimEnabled>().0 = true;
+        app.update();
+        assert!(app.world().get::<AnimationTransitions>(player).is_some());
+        assert!(app
+            .world()
+            .get::<SuspendedAnimationTransitions>(player)
+            .is_none());
+        assert!(!app
+            .world()
+            .get::<AnimationPlayer>(player)
+            .unwrap()
+            .all_paused());
+    }
+
+    #[test]
+    fn paused_preview_suspends_transition_advancement() {
+        let (mut app, actor, player, _) = runtime_test_app(false);
+        set_animation_preview(
+            app.world_mut(),
+            AnimationPreviewRequest {
+                actor,
+                state_id: "idle".into(),
+                seek_seconds: Some(0.5),
+                playing: false,
+            },
+        )
+        .unwrap();
+
+        app.update();
+
+        assert!(app.world().get::<AnimationTransitions>(player).is_none());
+        assert!(app
+            .world()
+            .get::<SuspendedAnimationTransitions>(player)
+            .is_some());
+        assert!(app
+            .world()
+            .get::<AnimationPlayer>(player)
+            .unwrap()
+            .all_paused());
+    }
+
+    #[test]
+    fn invalid_state_request_is_rejected_without_message_side_effect() {
+        let mut app = App::new();
+        app.add_message::<AnimationStateRequest>();
+        let actor = app
+            .world_mut()
+            .spawn(AnimationControllerDesc {
+                states: vec![state("idle", 0)],
+                default_state: "idle".into(),
+                ..Default::default()
+            })
+            .id();
+
+        let result = request_animation_state(
+            app.world_mut(),
+            AnimationStateRequest::new(actor, "missing"),
+        );
+        assert_eq!(
+            result.unwrap_err(),
+            "animation state `missing` does not exist"
+        );
+
+        let result = request_animation_state(
+            app.world_mut(),
+            AnimationStateRequest::new(actor, "idle").with_crossfade(f32::NAN),
+        );
+        assert_eq!(
+            result.unwrap_err(),
+            "animation crossfade must be finite and nonnegative"
+        );
+    }
+
+    #[test]
+    fn invalid_preview_seek_is_rejected() {
+        let mut app = App::new();
+        app.init_resource::<AnimationPreviewRuntime>();
+        let actor = app
+            .world_mut()
+            .spawn(AnimationControllerDesc {
+                states: vec![state("idle", 0)],
+                default_state: "idle".into(),
+                ..Default::default()
+            })
+            .id();
+
+        let result = set_animation_preview(
+            app.world_mut(),
+            AnimationPreviewRequest {
+                actor,
+                state_id: "idle".into(),
+                seek_seconds: Some(f32::INFINITY),
+                playing: false,
+            },
+        );
+        assert_eq!(result.unwrap_err(), "animation preview seek must be finite");
+    }
+
+    #[test]
+    fn runtime_diagnostics_are_bounded() {
+        let mut diagnostics = AnimationRuntimeDiagnostics::default();
+        for index in 0..(MAX_RUNTIME_DIAGNOSTICS + 4) {
+            diagnostics.push(None, "test", format!("diagnostic {index}"));
+        }
+        assert_eq!(diagnostics.entries().count(), MAX_RUNTIME_DIAGNOSTICS);
+        assert_eq!(
+            diagnostics.latest().map(|entry| entry.message.as_str()),
+            Some("diagnostic 67")
+        );
+    }
+}
diff --git a/crates/game/src/audio.rs b/crates/game/src/audio.rs
new file mode 100644
index 0000000..cadfab8
--- /dev/null
+++ b/crates/game/src/audio.rs
@@ -0,0 +1,919 @@
+//! Runtime audio hydration, bus controls, listener resolution, and diagnostics.
+
+use std::collections::{HashMap, HashSet};
+
+use bevy::audio::{
+    AudioPlayer, AudioSink, AudioSinkPlayback, AudioSource, PlaybackMode, PlaybackSettings,
+    SpatialAudioSink, SpatialListener, SpatialScale, Volume,
+};
+use bevy::prelude::*;
+use cpal::traits::{DeviceTrait, HostTrait};
+use settings::{
+    AudioSettings, ProjectSettings, AUDIO_BUS_MASTER_ID, AUDIO_GAIN_DB_MAX, AUDIO_GAIN_DB_MIN,
+};
+use shared::{
+    asset_server_path, inspector_component_active, ActorId, AudioAttenuationDesc,
+    AudioListenerDesc, AudioRolloff, AudioSourceDesc, InspectorOrder, LevelObject,
+    COMPONENT_AUDIO_LISTENER_DESC, COMPONENT_AUDIO_SOURCE_DESC,
+};
+use sim::{PlayerCamera, SimEnabled};
+
+/// Runtime override for an authored project bus. `None` preserves the project value.
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
+pub struct AudioBusOverride {
+    pub gain_db: Option<f32>,
+    pub muted: Option<bool>,
+}
+
+/// Mutable runtime mixer state used by gameplay and options menus.
+#[derive(Resource, Debug, Clone, Default)]
+pub struct AudioBusRuntime {
+    overrides: HashMap<String, AudioBusOverride>,
+}
+
+impl AudioBusRuntime {
+    pub fn set_gain_db(&mut self, bus_id: impl Into<String>, gain_db: f32) -> Result<(), String> {
+        if !gain_db.is_finite() {
+            return Err("audio bus gain must be finite".into());
+        }
+        self.overrides.entry(bus_id.into()).or_default().gain_db =
+            Some(gain_db.clamp(AUDIO_GAIN_DB_MIN, AUDIO_GAIN_DB_MAX));
+        Ok(())
+    }
+
+    pub fn set_muted(&mut self, bus_id: impl Into<String>, muted: bool) {
+        self.overrides.entry(bus_id.into()).or_default().muted = Some(muted);
+    }
+
+    pub fn clear_bus(&mut self, bus_id: &str) {
+        self.overrides.remove(bus_id);
+    }
+
+    pub fn clear(&mut self) {
+        self.overrides.clear();
+    }
+
+    pub fn bus_override(&self, bus_id: &str) -> Option<AudioBusOverride> {
+        self.overrides.get(bus_id).copied()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AudioDeviceStatus {
+    Unknown,
+    Available,
+    Unavailable,
+}
+
+/// User-facing audio backend and codec capability snapshot.
+#[derive(Resource, Debug, Clone)]
+pub struct AudioRuntimeDiagnostics {
+    pub status: AudioDeviceStatus,
+    pub backend: String,
+    pub output_device: Option<String>,
+    pub message: String,
+    pub codecs: Vec<String>,
+}
+
+impl Default for AudioRuntimeDiagnostics {
+    fn default() -> Self {
+        Self {
+            status: AudioDeviceStatus::Unknown,
+            backend: String::new(),
+            output_device: None,
+            message: "Audio output has not been probed yet.".into(),
+            codecs: vec![
+                "Ogg Vorbis".into(),
+                "WAV".into(),
+                "MP3".into(),
+                "FLAC".into(),
+            ],
+        }
+    }
+}
+
+#[derive(Resource, Debug, Clone, Copy, Default)]
+pub struct ActiveAudioListener(pub Option<Entity>);
+
+#[derive(Component, Debug, Clone, PartialEq)]
+struct RuntimeAudioSourceState {
+    descriptor: AudioSourceDesc,
+    desired_playing: bool,
+    paused_by_sim: bool,
+}
+
+#[derive(Component, Debug, Clone, Copy, PartialEq)]
+struct ManagedAudioListener {
+    ear_gap: f32,
+}
+
+#[derive(Component, Debug, Clone)]
+pub struct AuthoredAudioVoice {
+    pub source: Entity,
+    pub bus: String,
+    pub source_gain_db: f32,
+    pub mix_weight: f32,
+    pub spatial: bool,
+    pub attenuation: AudioAttenuationDesc,
+    pub looping: bool,
+}
+
+/// Runtime adapter for scene-authored audio descriptors.
+pub struct GameAudioPlugin;
+
+impl Plugin for GameAudioPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<AudioBusRuntime>()
+            .init_resource::<AudioRuntimeDiagnostics>()
+            .init_resource::<ActiveAudioListener>()
+            .add_systems(PostStartup, probe_audio_output)
+            .add_systems(
+                Update,
+                (
+                    reconcile_audio_listener,
+                    reconcile_audio_sources,
+                    update_voice_mix,
+                    cleanup_finished_voices,
+                )
+                    .chain(),
+            );
+    }
+}
+
+fn probe_audio_output(mut diagnostics: ResMut<AudioRuntimeDiagnostics>) {
+    let host = cpal::default_host();
+    diagnostics.backend = host.id().name().to_string();
+    match host.default_output_device() {
+        Some(device) => {
+            let name = device
+                .description()
+                .map(|description| description.name().to_string())
+                .unwrap_or_else(|error| format!("Unknown device ({error})"));
+            diagnostics.status = AudioDeviceStatus::Available;
+            diagnostics.output_device = Some(name.clone());
+            diagnostics.message = format!("Audio output ready on {name}.");
+        }
+        None => {
+            diagnostics.status = AudioDeviceStatus::Unavailable;
+            diagnostics.output_device = None;
+            diagnostics.message = "No default audio output device is available.".into();
+            warn!("{}", diagnostics.message);
+        }
+    }
+}
+
+/// Returns the effective linear gain for a bus including parent buses and runtime overrides.
+pub fn effective_bus_gain_linear(
+    settings: &AudioSettings,
+    runtime: &AudioBusRuntime,
+    requested_bus: &str,
+) -> f32 {
+    let mut current = if settings.bus(requested_bus).is_some() {
+        requested_bus
+    } else {
+        AUDIO_BUS_MASTER_ID
+    };
+    let mut visited = HashSet::new();
+    let mut gain_db = 0.0;
+
+    while visited.insert(current.to_string()) {
+        let Some(bus) = settings.bus(current) else {
+            break;
+        };
+        let runtime_override = runtime.bus_override(current).unwrap_or_default();
+        if runtime_override.muted.unwrap_or(bus.muted) {
+            return 0.0;
+        }
+        gain_db += runtime_override.gain_db.unwrap_or(bus.gain_db);
+        let Some(parent) = bus.parent.as_deref() else {
+            break;
+        };
+        current = parent;
+    }
+
+    db_to_linear(gain_db)
+}
+
+pub fn db_to_linear(db: f32) -> f32 {
+    if db <= AUDIO_GAIN_DB_MIN {
+        0.0
+    } else {
+        10.0_f32.powf(db / 20.0)
+    }
+}
+
+/// Equal-power 2D/spatial voice weights for a continuous authored blend.
+pub fn audio_voice_mix(spatial_blend: f32) -> Vec<(bool, f32)> {
+    let blend = spatial_blend.clamp(0.0, 1.0);
+    if blend <= f32::EPSILON {
+        vec![(false, 1.0)]
+    } else if blend >= 1.0 - f32::EPSILON {
+        vec![(true, 1.0)]
+    } else {
+        vec![(false, (1.0 - blend).sqrt()), (true, blend.sqrt())]
+    }
+}
+
+/// Authored attenuation curve, normalized to full gain at `min_distance` and silence at max.
+pub fn attenuation_gain(desc: &AudioAttenuationDesc, distance: f32) -> f32 {
+    if !distance.is_finite() {
+        return 0.0;
+    }
+    let min = desc.min_distance.max(0.001);
+    let max = desc.max_distance.max(min + 0.001);
+    if distance <= min {
+        return 1.0;
+    }
+    if distance >= max {
+        return 0.0;
+    }
+    let t = ((distance - min) / (max - min)).clamp(0.0, 1.0);
+    let factor = desc.rolloff_factor.max(0.001);
+    match desc.rolloff {
+        AudioRolloff::Linear => (1.0 - t).powf(factor),
+        AudioRolloff::Inverse => ((1.0 - t) / (1.0 + factor * 4.0 * t)).clamp(0.0, 1.0),
+        AudioRolloff::Exponential => ((distance / min).powf(-factor) * (1.0 - t)).clamp(0.0, 1.0),
+    }
+}
+
+/// Coordinate scale used only for rodio's left/right spatial panning.
+///
+/// Rodio also applies an inverse-square distance gain. Keeping every audible point inside its
+/// unity-distance zone preserves the interaural panning ratio while leaving the authored
+/// attenuation curve as the sole distance-gain authority.
+pub fn spatial_panning_scale(desc: &AudioAttenuationDesc, ear_gap: f32) -> f32 {
+    const RODIO_UNITY_ZONE_FRACTION: f32 = 0.25;
+
+    let audible_radius = if desc.max_distance.is_finite() {
+        desc.max_distance.max(0.001)
+    } else {
+        0.001
+    };
+    let ear_gap = if ear_gap.is_finite() {
+        ear_gap.max(0.001)
+    } else {
+        0.001
+    };
+    (RODIO_UNITY_ZONE_FRACTION / (audible_radius + ear_gap * 0.5)).max(f32::MIN_POSITIVE)
+}
+
+fn reconcile_audio_listener(world: &mut World) {
+    let enabled = world.resource::<SimEnabled>().0;
+    let mut candidates = Vec::new();
+    {
+        let mut query = world.query_filtered::<(
+            Entity,
+            &AudioListenerDesc,
+            Option<&ActorId>,
+            Option<&InspectorOrder>,
+        ), With<LevelObject>>();
+        for (entity, desc, actor_id, order) in query.iter(world) {
+            if desc.enabled && inspector_component_active(order, COMPONENT_AUDIO_LISTENER_DESC) {
+                candidates.push((
+                    entity,
+                    *desc,
+                    actor_id.map(|id| id.0.clone()).unwrap_or_default(),
+                ));
+            }
+        }
+    }
+    candidates.sort_by(|a, b| {
+        b.1.priority
+            .cmp(&a.1.priority)
+            .then_with(|| a.2.cmp(&b.2))
+            .then_with(|| a.0.to_bits().cmp(&b.0.to_bits()))
+    });
+
+    let selected = if enabled {
+        candidates
+            .first()
+            .map(|(entity, desc, _)| (*entity, desc.ear_gap))
+            .or_else(|| {
+                let mut query = world.query_filtered::<Entity, With<PlayerCamera>>();
+                query
+                    .iter(world)
+                    .min_by_key(|entity| entity.to_bits())
+                    .map(|entity| (entity, 0.2))
+            })
+    } else {
+        None
+    };
+
+    let mut managed_query = world.query::<(Entity, &ManagedAudioListener)>();
+    let managed: Vec<(Entity, ManagedAudioListener)> = managed_query
+        .iter(world)
+        .map(|(entity, listener)| (entity, *listener))
+        .collect();
+    for (entity, _) in managed {
+        if selected.is_none_or(|(selected, _)| selected != entity) {
+            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+                entity_mut
+                    .remove::<SpatialListener>()
+                    .remove::<ManagedAudioListener>();
+            }
+        }
+    }
+
+    if let Some((entity, ear_gap)) = selected {
+        let ear_gap = ear_gap.max(0.001);
+        let is_current = world
+            .get::<ManagedAudioListener>(entity)
+            .is_some_and(|listener| listener.ear_gap == ear_gap)
+            && world.get::<SpatialListener>(entity).is_some();
+        if !is_current {
+            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+                entity_mut.insert((
+                    SpatialListener::new(ear_gap),
+                    ManagedAudioListener { ear_gap },
+                ));
+            }
+        }
+    }
+    let selected_entity = selected.map(|(entity, _)| entity);
+    let mut active = world.resource_mut::<ActiveAudioListener>();
+    if active.0 != selected_entity {
+        active.0 = selected_entity;
+    }
+}
+
+fn reconcile_audio_sources(world: &mut World) {
+    let sim_enabled = world.resource::<SimEnabled>().0;
+    let mut sources = Vec::new();
+    {
+        let mut query = world.query_filtered::<(
+            Entity,
+            &AudioSourceDesc,
+            Option<&InspectorOrder>,
+        ), With<LevelObject>>();
+        for (entity, desc, order) in query.iter(world) {
+            if inspector_component_active(order, COMPONENT_AUDIO_SOURCE_DESC) {
+                sources.push((entity, desc.clone()));
+            }
+        }
+    }
+    let source_ids: HashSet<Entity> = sources.iter().map(|(entity, _)| *entity).collect();
+    let mut voice_query = world.query::<&AuthoredAudioVoice>();
+    let mut voiced_sources: HashSet<Entity> =
+        voice_query.iter(world).map(|voice| voice.source).collect();
+    let mut state_query = world.query_filtered::<Entity, With<RuntimeAudioSourceState>>();
+    let stale: Vec<Entity> = state_query
+        .iter(world)
+        .filter(|entity| !source_ids.contains(entity))
+        .collect();
+    for entity in stale {
+        stop_voice_entities(world, entity);
+        if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.remove::<RuntimeAudioSourceState>();
+        }
+    }
+
+    for (entity, descriptor) in sources {
+        let prior = world.get::<RuntimeAudioSourceState>(entity).cloned();
+        let mut state = prior.clone().unwrap_or_else(|| RuntimeAudioSourceState {
+            descriptor: descriptor.clone(),
+            desired_playing: descriptor.autoplay,
+            paused_by_sim: false,
+        });
+        if state.descriptor != descriptor {
+            let autoplay_changed = state.descriptor.autoplay != descriptor.autoplay;
+            stop_voice_entities(world, entity);
+            voiced_sources.remove(&entity);
+            state.descriptor = descriptor.clone();
+            if autoplay_changed {
+                state.desired_playing = descriptor.autoplay;
+            }
+        }
+
+        if !sim_enabled {
+            if !state.paused_by_sim {
+                set_source_paused(world, entity, true);
+                state.paused_by_sim = true;
+            }
+        } else {
+            if state.paused_by_sim {
+                set_source_paused(world, entity, false);
+                state.paused_by_sim = false;
+            }
+            if state.desired_playing && !voiced_sources.contains(&entity) {
+                if let Err(error) = spawn_source_voices(world, entity, &descriptor) {
+                    warn!("Could not start authored audio source {entity:?}: {error}");
+                    state.desired_playing = false;
+                } else {
+                    voiced_sources.insert(entity);
+                }
+            }
+        }
+        if prior.as_ref() != Some(&state) {
+            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+                entity_mut.insert(state);
+            }
+        }
+    }
+}
+
+fn spawn_source_voices(
+    world: &mut World,
+    source: Entity,
+    descriptor: &AudioSourceDesc,
+) -> Result<(), String> {
+    let clip = descriptor
+        .clip
+        .as_ref()
+        .ok_or_else(|| "no audio clip is assigned".to_string())?;
+    let source_path = clip
+        .source_path
+        .as_deref()
+        .filter(|path| !path.trim().is_empty())
+        .ok_or_else(|| "audio clip has no runtime source path".to_string())?;
+    let asset_server = world.resource::<AssetServer>().clone();
+    let handle: Handle<AudioSource> = asset_server.load(asset_server_path(source_path));
+    let mode = if descriptor.looping {
+        PlaybackMode::Loop
+    } else {
+        PlaybackMode::Once
+    };
+    let ear_gap = active_listener_ear_gap(world);
+    let panning_scale = spatial_panning_scale(&descriptor.attenuation, ear_gap);
+
+    for (spatial, mix_weight) in audio_voice_mix(descriptor.spatial_blend) {
+        let child = world
+            .spawn((
+                Name::new(if spatial {
+                    "Authored Spatial Audio Voice"
+                } else {
+                    "Authored 2D Audio Voice"
+                }),
+                Transform::IDENTITY,
+                AudioPlayer::new(handle.clone()),
+                PlaybackSettings {
+                    mode,
+                    volume: Volume::Linear(0.0),
+                    speed: descriptor.pitch,
+                    paused: false,
+                    muted: false,
+                    spatial,
+                    spatial_scale: spatial.then(|| SpatialScale::new(panning_scale)),
+                    start_position: None,
+                    duration: None,
+                },
+                AuthoredAudioVoice {
+                    source,
+                    bus: descriptor.bus.clone(),
+                    source_gain_db: descriptor.gain_db,
+                    mix_weight,
+                    spatial,
+                    attenuation: descriptor.attenuation,
+                    looping: descriptor.looping,
+                },
+                ChildOf(source),
+            ))
+            .id();
+        trace!("Spawned authored audio voice {child:?} for {source:?}");
+    }
+    Ok(())
+}
+
+fn active_listener_ear_gap(world: &World) -> f32 {
+    world
+        .resource::<ActiveAudioListener>()
+        .0
+        .and_then(|entity| world.get::<ManagedAudioListener>(entity))
+        .map(|listener| listener.ear_gap)
+        .unwrap_or(0.2)
+}
+
+fn voice_entities(world: &mut World, source: Entity) -> Vec<Entity> {
+    let mut query = world.query::<(Entity, &AuthoredAudioVoice)>();
+    query
+        .iter(world)
+        .filter_map(|(entity, voice)| (voice.source == source).then_some(entity))
+        .collect()
+}
+
+fn stop_voice_entities(world: &mut World, source: Entity) {
+    for entity in voice_entities(world, source) {
+        if let Some(sink) = world.get::<AudioSink>(entity) {
+            sink.stop();
+        }
+        if let Some(sink) = world.get::<SpatialAudioSink>(entity) {
+            sink.stop();
+        }
+        if let Ok(entity_mut) = world.get_entity_mut(entity) {
+            entity_mut.despawn();
+        }
+    }
+}
+
+fn set_source_paused(world: &mut World, source: Entity, paused: bool) {
+    for entity in voice_entities(world, source) {
+        if let Some(mut settings) = world.get_mut::<PlaybackSettings>(entity) {
+            settings.paused = paused;
+        }
+        if let Some(sink) = world.get::<AudioSink>(entity) {
+            if paused {
+                sink.pause();
+            } else {
+                sink.play();
+            }
+        }
+        if let Some(sink) = world.get::<SpatialAudioSink>(entity) {
+            if paused {
+                sink.pause();
+            } else {
+                sink.play();
+            }
+        }
+    }
+}
+
+/// Starts an authored source through the same runtime adapter used by autoplay.
+pub fn play_authored_audio_source(world: &mut World, source: Entity) -> Result<(), String> {
+    let descriptor = world
+        .get::<AudioSourceDesc>(source)
+        .cloned()
+        .ok_or_else(|| "entity has no AudioSourceDesc".to_string())?;
+    stop_voice_entities(world, source);
+    let sim_enabled = world.resource::<SimEnabled>().0;
+    let state = RuntimeAudioSourceState {
+        descriptor: descriptor.clone(),
+        desired_playing: true,
+        paused_by_sim: !sim_enabled,
+    };
+    world.entity_mut(source).insert(state);
+    if sim_enabled {
+        spawn_source_voices(world, source, &descriptor)?;
+    }
+    Ok(())
+}
+
+/// Stops an authored source and disables replay until another explicit play or autoplay change.
+pub fn stop_authored_audio_source(world: &mut World, source: Entity) {
+    stop_voice_entities(world, source);
+    if let Some(mut state) = world.get_mut::<RuntimeAudioSourceState>(source) {
+        state.desired_playing = false;
+        state.paused_by_sim = false;
+    }
+}
+
+/// Clears PIE-owned playback/listeners so the next session starts from authored state.
+pub fn reset_authored_audio_runtime(world: &mut World) {
+    let mut query = world.query_filtered::<Entity, With<RuntimeAudioSourceState>>();
+    let sources: Vec<Entity> = query.iter(world).collect();
+    for source in sources {
+        stop_voice_entities(world, source);
+        if let Ok(mut entity_mut) = world.get_entity_mut(source) {
+            entity_mut.remove::<RuntimeAudioSourceState>();
+        }
+    }
+    let mut listener_query = world.query_filtered::<Entity, With<ManagedAudioListener>>();
+    let listeners: Vec<Entity> = listener_query.iter(world).collect();
+    for listener in listeners {
+        if let Ok(mut entity_mut) = world.get_entity_mut(listener) {
+            entity_mut
+                .remove::<SpatialListener>()
+                .remove::<ManagedAudioListener>();
+        }
+    }
+    world.resource_mut::<ActiveAudioListener>().0 = None;
+}
+
+fn update_voice_mix(world: &mut World) {
+    let project_audio = world.resource::<ProjectSettings>().audio.clone();
+    let bus_runtime = world.resource::<AudioBusRuntime>().clone();
+    let listener_position = world
+        .resource::<ActiveAudioListener>()
+        .0
+        .and_then(|entity| world.get::<GlobalTransform>(entity))
+        .map(GlobalTransform::translation);
+    let listener_ear_gap = active_listener_ear_gap(world);
+    let mut query = world.query::<(Entity, &AuthoredAudioVoice, Option<&GlobalTransform>)>();
+    let voices: Vec<(Entity, AuthoredAudioVoice, Option<Vec3>)> = query
+        .iter(world)
+        .map(|(entity, voice, transform)| {
+            (
+                entity,
+                voice.clone(),
+                transform.map(GlobalTransform::translation),
+            )
+        })
+        .collect();
+
+    for (entity, voice, source_position) in voices {
+        if voice.spatial {
+            let scale = spatial_panning_scale(&voice.attenuation, listener_ear_gap);
+            let desired = SpatialScale::new(scale);
+            if let Some(mut settings) = world.get_mut::<PlaybackSettings>(entity) {
+                if settings
+                    .spatial_scale
+                    .is_none_or(|current| current.0 != desired.0)
+                {
+                    settings.spatial_scale = Some(desired);
+                }
+            }
+        }
+        let bus_gain = effective_bus_gain_linear(&project_audio, &bus_runtime, &voice.bus);
+        let attenuation = if voice.spatial {
+            match (listener_position, source_position) {
+                (Some(listener), Some(source)) => {
+                    attenuation_gain(&voice.attenuation, listener.distance(source))
+                }
+                _ => 0.0,
+            }
+        } else {
+            1.0
+        };
+        let gain = db_to_linear(voice.source_gain_db) * bus_gain * voice.mix_weight * attenuation;
+        if let Some(mut sink) = world.get_mut::<AudioSink>(entity) {
+            sink.set_volume(Volume::Linear(gain));
+        }
+        if let Some(mut sink) = world.get_mut::<SpatialAudioSink>(entity) {
+            sink.set_volume(Volume::Linear(gain));
+        }
+    }
+}
+
+fn cleanup_finished_voices(world: &mut World) {
+    let mut query = world.query::<(Entity, &AuthoredAudioVoice)>();
+    let voices: Vec<(Entity, Entity, bool)> = query
+        .iter(world)
+        .map(|(entity, voice)| (entity, voice.source, voice.looping))
+        .collect();
+    let mut completed_sources = HashSet::new();
+    for (entity, source, looping) in voices {
+        if looping {
+            continue;
+        }
+        let finished = world
+            .get::<AudioSink>(entity)
+            .is_some_and(AudioSinkPlayback::empty)
+            || world
+                .get::<SpatialAudioSink>(entity)
+                .is_some_and(AudioSinkPlayback::empty);
+        if finished {
+            if let Ok(entity_mut) = world.get_entity_mut(entity) {
+                entity_mut.despawn();
+            }
+            completed_sources.insert(source);
+        }
+    }
+    for source in completed_sources {
+        if voice_entities(world, source).is_empty() {
+            if let Some(mut state) = world.get_mut::<RuntimeAudioSourceState>(source) {
+                state.desired_playing = false;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::{AssetApp, AssetPlugin};
+    use settings::{AudioBusSettings, AUDIO_BUS_MUSIC_ID, AUDIO_BUS_SFX_ID};
+    use shared::{EditorAssetRef, AUDIO_CLIP_SUB_ASSET_ID};
+
+    #[test]
+    fn bus_gain_accumulates_parents_and_runtime_overrides() {
+        let settings = AudioSettings::default();
+        let mut runtime = AudioBusRuntime::default();
+        runtime.set_gain_db(AUDIO_BUS_MASTER_ID, -6.0).unwrap();
+        runtime.set_gain_db(AUDIO_BUS_MUSIC_ID, -6.0).unwrap();
+        let gain = effective_bus_gain_linear(&settings, &runtime, AUDIO_BUS_MUSIC_ID);
+        assert!((gain - db_to_linear(-12.0)).abs() < 0.0001);
+        runtime.set_muted(AUDIO_BUS_MASTER_ID, true);
+        assert_eq!(
+            effective_bus_gain_linear(&settings, &runtime, AUDIO_BUS_MUSIC_ID),
+            0.0
+        );
+    }
+
+    #[test]
+    fn missing_bus_falls_back_to_master() {
+        let mut settings = AudioSettings::default();
+        settings.bus_mut(AUDIO_BUS_MASTER_ID).unwrap().gain_db = -3.0;
+        assert!(
+            (effective_bus_gain_linear(&settings, &AudioBusRuntime::default(), "missing")
+                - db_to_linear(-3.0))
+            .abs()
+                < 0.0001
+        );
+    }
+
+    #[test]
+    fn spatial_blend_is_equal_power_and_keeps_endpoint_voice_counts() {
+        assert_eq!(audio_voice_mix(0.0), vec![(false, 1.0)]);
+        assert_eq!(audio_voice_mix(1.0), vec![(true, 1.0)]);
+        let mixed = audio_voice_mix(0.5);
+        assert_eq!(mixed.len(), 2);
+        let power: f32 = mixed.iter().map(|(_, weight)| weight * weight).sum();
+        assert!((power - 1.0).abs() < 0.0001);
+    }
+
+    #[test]
+    fn attenuation_is_full_inside_min_and_silent_at_max() {
+        for rolloff in [
+            AudioRolloff::Linear,
+            AudioRolloff::Inverse,
+            AudioRolloff::Exponential,
+        ] {
+            let desc = AudioAttenuationDesc {
+                min_distance: 2.0,
+                max_distance: 10.0,
+                rolloff,
+                rolloff_factor: 1.0,
+            };
+            assert_eq!(attenuation_gain(&desc, 1.0), 1.0);
+            assert_eq!(attenuation_gain(&desc, 10.0), 0.0);
+            assert!(attenuation_gain(&desc, 5.0) > 0.0);
+        }
+    }
+
+    #[test]
+    fn panning_scale_keeps_rodio_distance_gain_neutral_in_authored_radius() {
+        let attenuation = AudioAttenuationDesc {
+            min_distance: 1.0,
+            max_distance: 25.0,
+            rolloff: AudioRolloff::Inverse,
+            rolloff_factor: 1.0,
+        };
+        let ear_gap = 0.2;
+        let scale = spatial_panning_scale(&attenuation, ear_gap);
+
+        // Rodio's distance gain remains 1.0 while each ear is at most one rodio unit away.
+        let furthest_audible_ear = (attenuation.max_distance + ear_gap * 0.5) * scale;
+        assert!(scale.is_finite() && scale > 0.0);
+        assert!(furthest_audible_ear <= 0.25 + f32::EPSILON);
+    }
+
+    #[test]
+    fn unchanged_reconciliation_does_not_reinsert_runtime_components() {
+        let mut world = World::new();
+        world.insert_resource(SimEnabled(true));
+        world.insert_resource(ActiveAudioListener::default());
+        let listener = world
+            .spawn((
+                LevelObject,
+                ActorId("audio-listener".into()),
+                AudioListenerDesc::default(),
+            ))
+            .id();
+        let source = world
+            .spawn((
+                LevelObject,
+                AudioSourceDesc {
+                    autoplay: false,
+                    ..Default::default()
+                },
+            ))
+            .id();
+
+        reconcile_audio_listener(&mut world);
+        reconcile_audio_sources(&mut world);
+        world.clear_trackers();
+        reconcile_audio_listener(&mut world);
+        reconcile_audio_sources(&mut world);
+
+        assert!(!world
+            .entity(listener)
+            .get_ref::<ManagedAudioListener>()
+            .unwrap()
+            .is_changed());
+        assert!(!world
+            .entity(source)
+            .get_ref::<RuntimeAudioSourceState>()
+            .unwrap()
+            .is_changed());
+    }
+
+    #[test]
+    fn authored_audio_hydrates_and_reset_removes_all_runtime_state() {
+        let mut app = App::new();
+        app.add_plugins((MinimalPlugins, AssetPlugin::default()))
+            .init_asset::<AudioSource>()
+            .insert_resource(SimEnabled(true))
+            .init_resource::<ActiveAudioListener>();
+        let listener = app
+            .world_mut()
+            .spawn((
+                LevelObject,
+                ActorId("audio-listener".into()),
+                AudioListenerDesc::default(),
+                Transform::IDENTITY,
+            ))
+            .id();
+        let source = app
+            .world_mut()
+            .spawn((
+                LevelObject,
+                Transform::from_xyz(0.0, 0.0, -2.0),
+                AudioSourceDesc {
+                    clip: Some(
+                        EditorAssetRef::new("audio-id", AUDIO_CLIP_SUB_ASSET_ID, "Tone")
+                            .with_source_path("audio/tone.ogg"),
+                    ),
+                    spatial_blend: 0.5,
+                    ..Default::default()
+                },
+            ))
+            .id();
+
+        reconcile_audio_listener(app.world_mut());
+        reconcile_audio_sources(app.world_mut());
+
+        assert_eq!(
+            app.world().resource::<ActiveAudioListener>().0,
+            Some(listener)
+        );
+        assert!(app.world().get::<SpatialListener>(listener).is_some());
+        assert!(app.world().get::<RuntimeAudioSourceState>(source).is_some());
+        let voices = voice_entities(app.world_mut(), source);
+        assert_eq!(voices.len(), 2);
+        assert!(voices
+            .iter()
+            .all(|voice| app.world().get::<AudioPlayer>(*voice).is_some()));
+
+        reset_authored_audio_runtime(app.world_mut());
+
+        assert_eq!(app.world().resource::<ActiveAudioListener>().0, None);
+        assert!(app.world().get::<SpatialListener>(listener).is_none());
+        assert!(app.world().get::<RuntimeAudioSourceState>(source).is_none());
+        assert!(voice_entities(app.world_mut(), source).is_empty());
+    }
+
+    #[test]
+    fn listener_selection_prefers_priority_then_stable_actor_id() {
+        let mut world = World::new();
+        world.insert_resource(SimEnabled(true));
+        world.insert_resource(ActiveAudioListener::default());
+        let low_priority = world
+            .spawn((
+                LevelObject,
+                ActorId("listener-low".into()),
+                AudioListenerDesc {
+                    priority: 1,
+                    ..Default::default()
+                },
+            ))
+            .id();
+        let tied_later = world
+            .spawn((
+                LevelObject,
+                ActorId("listener-z".into()),
+                AudioListenerDesc {
+                    priority: 10,
+                    ..Default::default()
+                },
+            ))
+            .id();
+        let tied_first = world
+            .spawn((
+                LevelObject,
+                ActorId("listener-a".into()),
+                AudioListenerDesc {
+                    priority: 10,
+                    ..Default::default()
+                },
+            ))
+            .id();
+
+        reconcile_audio_listener(&mut world);
+        assert_eq!(world.resource::<ActiveAudioListener>().0, Some(tied_first));
+        assert_ne!(
+            world.resource::<ActiveAudioListener>().0,
+            Some(low_priority)
+        );
+
+        world
+            .get_mut::<AudioListenerDesc>(tied_first)
+            .unwrap()
+            .enabled = false;
+        reconcile_audio_listener(&mut world);
+        assert_eq!(world.resource::<ActiveAudioListener>().0, Some(tied_later));
+    }
+
+    #[test]
+    fn bus_cycle_is_defensively_bounded_at_runtime() {
+        let settings = AudioSettings {
+            buses: vec![
+                AudioBusSettings {
+                    id: AUDIO_BUS_MASTER_ID.into(),
+                    label: "Master".into(),
+                    parent: Some(AUDIO_BUS_SFX_ID.into()),
+                    gain_db: 0.0,
+                    muted: false,
+                },
+                AudioBusSettings {
+                    id: AUDIO_BUS_SFX_ID.into(),
+                    label: "SFX".into(),
+                    parent: Some(AUDIO_BUS_MASTER_ID.into()),
+                    gain_db: 0.0,
+                    muted: false,
+                },
+            ],
+        };
+        assert_eq!(
+            effective_bus_gain_linear(&settings, &AudioBusRuntime::default(), AUDIO_BUS_SFX_ID),
+            1.0
+        );
+    }
+}
diff --git a/crates/game/src/launch.rs b/crates/game/src/launch.rs
index 18b3740..432e455 100644
--- a/crates/game/src/launch.rs
+++ b/crates/game/src/launch.rs
@@ -4,6 +4,7 @@ use std::path::{Path, PathBuf};
 
 use bevy::app::PluginGroupBuilder;
 use bevy::asset::AssetPlugin;
+use bevy::log::{LogPlugin, DEFAULT_FILTER};
 use bevy::prelude::*;
 use bevy::window::{CompositeAlphaMode, PresentMode, WindowMode, WindowPlugin};
 
@@ -40,6 +41,13 @@ fn find_assets_directory(start: Option<PathBuf>) -> Option<String> {
 
 pub fn default_plugins(title: impl Into<String>) -> PluginGroupBuilder {
     DefaultPlugins
+        .set(LogPlugin {
+            // Blacksite intentionally replaces Bevy's `.scn.ron` loader with a
+            // schema-aware loader. Keep the expected registration warning out
+            // of normal startup logs; RUST_LOG still overrides this filter.
+            filter: format!("{DEFAULT_FILTER}bevy_asset::server::loaders=error"),
+            ..default()
+        })
         .set(WindowPlugin {
             primary_window: Some(primary_window(title)),
             ..default()
diff --git a/crates/game/src/lib.rs b/crates/game/src/lib.rs
index c27e397..dc94c3d 100644
--- a/crates/game/src/lib.rs
+++ b/crates/game/src/lib.rs
@@ -8,8 +8,14 @@
     )
 )]
 
+pub mod animation;
+pub mod audio;
 pub mod editor_ext;
 pub mod launch;
+mod scene_bootstrap;
+mod schema_world_loader;
+
+pub use scene_bootstrap::ProjectDefaultLevelRoot;
 
 pub mod player {
     //! Player types re-exported from the stable sim crate.
@@ -42,6 +48,13 @@ pub struct GameRenderBootstrap {
     pub defer_player_camera_fx: bool,
 }
 
+/// Scene-startup controls for a host that embeds [`GamePlugin`].
+#[derive(Resource, Debug, Clone, Copy, Default)]
+pub struct GameSceneBootstrap {
+    /// The host owns initial scene materialization instead of the standalone runtime.
+    pub defer_default_level: bool,
+}
+
 #[cfg(not(feature = "hot-reload"))]
 mod systems {
     pub use game_hot::{
@@ -112,7 +125,21 @@ fn game_input_enabled(enabled: Res<GameInputEnabled>) -> bool {
     enabled.0
 }
 
-fn register_game_systems(app: &mut App, defer_player_camera_fx: bool) {
+fn register_level_bootstrap(app: &mut App, defer_default_level: bool) {
+    if defer_default_level {
+        // SceneIo owns editor startup and retains the generated arena as its
+        // failure fallback until the authored document is materialized.
+        app.add_systems(Startup, systems::spawn_level);
+    } else {
+        app.add_systems(Startup, scene_bootstrap::spawn_project_default_level);
+    }
+}
+
+fn register_game_systems(
+    app: &mut App,
+    render_bootstrap: GameRenderBootstrap,
+    scene_bootstrap: GameSceneBootstrap,
+) {
     app.add_systems(
         FixedUpdate,
         (
@@ -143,13 +170,10 @@ fn register_game_systems(app: &mut App, defer_player_camera_fx: bool) {
     )
     .add_systems(
         Startup,
-        (
-            systems::apply_ambient_light,
-            systems::spawn_sun,
-            systems::spawn_level,
-        )
-            .chain(),
+        (systems::apply_ambient_light, systems::spawn_sun).chain(),
     );
+
+    register_level_bootstrap(app, scene_bootstrap.defer_default_level);
     app.add_systems(
         Update,
         (
@@ -158,7 +182,7 @@ fn register_game_systems(app: &mut App, defer_player_camera_fx: bool) {
         ),
     );
 
-    if !defer_player_camera_fx {
+    if !render_bootstrap.defer_player_camera_fx {
         app.add_systems(
             PostStartup,
             (
@@ -175,21 +199,29 @@ pub struct GamePlugin;
 
 impl Plugin for GamePlugin {
     fn build(&self, app: &mut App) {
-        let defer_player_camera_fx = app
+        let render_bootstrap = app
             .world()
             .get_resource::<GameRenderBootstrap>()
-            .is_some_and(|bootstrap| bootstrap.defer_player_camera_fx);
+            .copied()
+            .unwrap_or_default();
+        let scene_bootstrap = app
+            .world()
+            .get_resource::<GameSceneBootstrap>()
+            .copied()
+            .unwrap_or_default();
 
         app.register_type::<GameInputEnabled>()
             .init_resource::<GameInputEnabled>()
             .init_resource::<GameInputFocused>()
+            .add_plugins(schema_world_loader::SchemaWorldAssetPlugin)
             .add_plugins((ProjectSettingsPlugin, SimPlugin, bevy_ufbx::FbxPlugin))
+            .add_plugins((audio::GameAudioPlugin, animation::GameAnimationPlugin))
             .add_plugins(game_hot::SolariRenderingPlugin)
             .add_plugins(game_hot::AutoExposureRenderingPlugin)
             .add_plugins(game_hot::FullscreenEffectsPlugin)
             .insert_resource(ClearColor(Color::srgb(0.0, 0.0, 0.0)));
 
-        register_game_systems(app, defer_player_camera_fx);
+        register_game_systems(app, render_bootstrap, scene_bootstrap);
     }
 }
 
@@ -197,3 +229,34 @@ impl Plugin for GamePlugin {
 pub fn on_hot_reload(world: &mut World) {
     game_hot::on_hot_reload(world);
 }
+
+#[cfg(test)]
+mod startup_tests {
+    use super::*;
+    use bevy::asset::AssetPlugin;
+    use bevy::world_serialization::WorldSerializationPlugin;
+
+    #[test]
+    fn deferred_bootstrap_leaves_default_level_loading_to_the_host() {
+        let mut app = App::new();
+        app.add_plugins((
+            MinimalPlugins,
+            AssetPlugin::default(),
+            WorldSerializationPlugin,
+        ));
+        app.insert_resource(settings::ProjectSettings::default());
+        register_level_bootstrap(&mut app, true);
+
+        app.update();
+
+        let world = app.world_mut();
+        let mut runtime_roots =
+            world.query_filtered::<Entity, With<scene_bootstrap::ProjectDefaultLevelRoot>>();
+        assert_eq!(runtime_roots.iter(world).count(), 0);
+        let mut fallback = world.query_filtered::<Entity, With<shared::LevelObject>>();
+        assert!(
+            fallback.iter(world).next().is_some(),
+            "the editor fallback arena remains available until SceneIo loads"
+        );
+    }
+}
diff --git a/crates/game/src/scene_bootstrap.rs b/crates/game/src/scene_bootstrap.rs
new file mode 100644
index 0000000..d4510c5
--- /dev/null
+++ b/crates/game/src/scene_bootstrap.rs
@@ -0,0 +1,85 @@
+//! Standalone project-scene bootstrap.
+
+use bevy::prelude::*;
+use bevy::world_serialization::DynamicWorld;
+use settings::ProjectSettings;
+
+/// Runtime root for the standalone project's configured default level.
+#[derive(Component, Debug)]
+pub struct ProjectDefaultLevelRoot;
+
+pub(crate) fn spawn_project_default_level(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    settings: Res<ProjectSettings>,
+    existing: Query<(), With<ProjectDefaultLevelRoot>>,
+) {
+    if !existing.is_empty() {
+        return;
+    }
+
+    let configured_path = settings.default_level.trim();
+    if configured_path.is_empty() {
+        error!("Project default_level is empty; standalone scene startup was skipped");
+        return;
+    }
+
+    let asset_path = shared::asset_server_path(configured_path);
+    let handle: Handle<DynamicWorld> = asset_server.load(asset_path.clone());
+    commands.spawn((
+        Name::new(format!("Project Default Level ({configured_path})")),
+        ProjectDefaultLevelRoot,
+        DynamicWorldRoot(handle),
+    ));
+    info!("Loading project default level {configured_path} ({asset_path})");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::AssetPlugin;
+    use bevy::world_serialization::WorldSerializationPlugin;
+
+    fn test_app(default_level: &str) -> App {
+        let mut app = App::new();
+        app.add_plugins((
+            MinimalPlugins,
+            AssetPlugin::default(),
+            WorldSerializationPlugin,
+        ));
+        app.insert_resource(ProjectSettings {
+            default_level: default_level.to_string(),
+            ..Default::default()
+        });
+        app
+    }
+
+    #[test]
+    fn standalone_bootstrap_uses_the_project_default_level() {
+        let mut app = test_app("assets/levels/editor_scene.scn.ron");
+        app.add_systems(Startup, spawn_project_default_level);
+
+        app.update();
+
+        let world = app.world_mut();
+        let mut roots = world.query_filtered::<&DynamicWorldRoot, With<ProjectDefaultLevelRoot>>();
+        let root = roots.single(world).expect("one standalone scene root");
+        let path = world
+            .resource::<AssetServer>()
+            .get_path(root.0.id())
+            .expect("default level handle retains its asset path");
+        assert_eq!(path.to_string(), "levels/editor_scene.scn.ron");
+    }
+
+    #[test]
+    fn empty_default_level_does_not_create_a_runtime_root() {
+        let mut app = test_app("   ");
+        app.add_systems(Startup, spawn_project_default_level);
+
+        app.update();
+
+        let world = app.world_mut();
+        let mut roots = world.query_filtered::<Entity, With<ProjectDefaultLevelRoot>>();
+        assert_eq!(roots.iter(world).count(), 0);
+    }
+}
diff --git a/crates/game/src/schema_world_loader.rs b/crates/game/src/schema_world_loader.rs
new file mode 100644
index 0000000..077b528
--- /dev/null
+++ b/crates/game/src/schema_world_loader.rs
@@ -0,0 +1,160 @@
+//! Runtime adapter for versioned Blacksite `.scn.ron` assets.
+
+use std::io;
+
+use bevy::asset::{io::Reader, AssetApp, AssetLoader, LoadContext};
+use bevy::ecs::reflect::AppTypeRegistry;
+use bevy::prelude::*;
+use bevy::reflect::{TypePath, TypeRegistryArc};
+use bevy::world_serialization::{serde::WorldDeserializer, DynamicWorld};
+use serde::de::DeserializeSeed;
+
+pub(super) struct SchemaWorldAssetPlugin;
+
+impl Plugin for SchemaWorldAssetPlugin {
+    fn build(&self, app: &mut App) {
+        // Register after Bevy's stock loader so versioned Blacksite scenes use
+        // this adapter while retaining the standard DynamicWorld asset type.
+        app.init_asset_loader::<SchemaWorldAssetLoader>();
+    }
+}
+
+#[derive(Debug, TypePath)]
+struct SchemaWorldAssetLoader {
+    type_registry: TypeRegistryArc,
+}
+
+impl FromWorld for SchemaWorldAssetLoader {
+    fn from_world(world: &mut World) -> Self {
+        Self {
+            type_registry: world.resource::<AppTypeRegistry>().0.clone(),
+        }
+    }
+}
+
+impl AssetLoader for SchemaWorldAssetLoader {
+    type Asset = DynamicWorld;
+    type Settings = ();
+    type Error = io::Error;
+
+    async fn load(
+        &self,
+        reader: &mut dyn Reader,
+        _settings: &Self::Settings,
+        load_context: &mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+        let text = std::str::from_utf8(&bytes).map_err(invalid_scene)?;
+        let body = normalized_world_body(text)?;
+        let mut deserializer = ron::de::Deserializer::from_str(&body).map_err(invalid_scene)?;
+        let world_deserializer = WorldDeserializer {
+            type_registry: &self.type_registry.read(),
+            load_from_path: load_context,
+        };
+        world_deserializer
+            .deserialize(&mut deserializer)
+            .map_err(|error| invalid_scene(deserializer.span_error(error)))
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["scn.ron"]
+    }
+}
+
+fn normalized_world_body(text: &str) -> Result<String, io::Error> {
+    scene::validate_level_text(text).map_err(invalid_scene)?;
+    let migrated = scene::migrate_scene_text(text).map_err(invalid_scene)?;
+    scene::strip_schema_version(&migrated).map_err(invalid_scene)
+}
+
+fn invalid_scene(error: impl std::fmt::Display) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, error.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::normalized_world_body;
+    use super::SchemaWorldAssetPlugin;
+    use bevy::asset::{AssetPlugin, AssetServer, Assets, LoadState};
+    use bevy::prelude::*;
+    use bevy::world_serialization::{DynamicWorld, WorldSerializationPlugin};
+
+    #[test]
+    fn versioned_world_assets_are_validated_and_unwrapped_for_bevy() {
+        let body = normalized_world_body(
+            r#"(schema_version: 2, resources: {}, entities: {
+                1: (components: { "shared::components::LevelObject": () }),
+            })"#,
+        )
+        .unwrap();
+
+        assert!(body.starts_with("(resources:"));
+        assert!(!body.contains("schema_version"));
+    }
+
+    #[test]
+    fn invalid_hierarchy_is_rejected_before_world_deserialization() {
+        let error = normalized_world_body(
+            r#"(schema_version: 2, resources: {}, entities: {
+                1: (components: { "bevy_ecs::hierarchy::ChildOf": (9) }),
+            })"#,
+        )
+        .unwrap_err();
+
+        assert!(error.to_string().contains("missing hierarchy parent `9`"));
+    }
+
+    #[test]
+    fn asset_server_loads_the_committed_versioned_prefab_fixture() {
+        let assets = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets");
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin {
+                file_path: assets.to_string_lossy().into_owned(),
+                ..default()
+            })
+            .add_plugins(WorldSerializationPlugin)
+            .register_type::<Name>()
+            .register_type::<Transform>()
+            .register_type::<shared::LevelObject>()
+            .register_type::<shared::ActorId>()
+            .register_type::<shared::ActorKind>()
+            .register_type::<shared::EditorVisibility>()
+            .register_type::<shared::PrefabInstance>()
+            .register_type::<shared::PrefabRef>()
+            .add_plugins(SchemaWorldAssetPlugin);
+
+        let handle: Handle<DynamicWorld> = app
+            .world()
+            .resource::<AssetServer>()
+            .load("prefabs/example_variant.scn.ron");
+        for _ in 0..200 {
+            app.update();
+            if app
+                .world()
+                .resource::<Assets<DynamicWorld>>()
+                .get(&handle)
+                .is_some()
+            {
+                return;
+            }
+            if matches!(
+                app.world()
+                    .resource::<AssetServer>()
+                    .load_state(handle.id()),
+                LoadState::Failed(_)
+            ) {
+                break;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(5));
+        }
+
+        panic!(
+            "versioned prefab fixture did not load: {:?}",
+            app.world()
+                .resource::<AssetServer>()
+                .load_state(handle.id())
+        );
+    }
+}
diff --git a/crates/scene/Cargo.toml b/crates/scene/Cargo.toml
index 7aa93be..5a2486b 100644
--- a/crates/scene/Cargo.toml
+++ b/crates/scene/Cargo.toml
@@ -6,6 +6,9 @@ license.workspace = true
 description = "Level scene schema versioning and validation (no Bevy dependency)"
 
 [dependencies]
+blake3 = "1"
 serde = { workspace = true }
 ron = "0.8"
+ron-edit = "=0.2.0"
 shared.workspace = true
+settings.workspace = true
diff --git a/crates/scene/src/composition.rs b/crates/scene/src/composition.rs
new file mode 100644
index 0000000..96fcb4d
--- /dev/null
+++ b/crates/scene/src/composition.rs
@@ -0,0 +1,279 @@
+//! Stable subscene reference validation for authored level compositions.
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Component, Path, PathBuf};
+
+use shared::SceneComposition;
+
+use crate::document::SceneDocument;
+
+pub fn validate_scene_composition(composition: &SceneComposition) -> Result<(), String> {
+    if composition.scene_id.trim().is_empty() {
+        return Err("scene composition has an empty scene_id".to_string());
+    }
+    let mut reference_ids = HashSet::new();
+    for reference in &composition.subscenes {
+        if reference.id.trim().is_empty() {
+            return Err("subscene reference has an empty id".to_string());
+        }
+        if !reference_ids.insert(reference.id.as_str()) {
+            return Err(format!(
+                "scene composition contains duplicate subscene id `{}`",
+                reference.id
+            ));
+        }
+        validate_project_relative_path(&reference.path)?;
+    }
+    Ok(())
+}
+
+pub fn validate_composition_graph(entry: &Path, project_root: &Path) -> Result<(), String> {
+    let entry = canonical_existing(entry)?;
+    let project_root = canonical_existing(project_root)?;
+    let mut visiting = Vec::new();
+    let mut visited = HashSet::new();
+    let mut scene_ids = HashMap::<String, PathBuf>::new();
+    visit_scene(
+        &entry,
+        &project_root,
+        &mut visiting,
+        &mut visited,
+        &mut scene_ids,
+    )
+}
+
+pub(crate) fn find_project_root(path: &Path) -> Option<PathBuf> {
+    let absolute = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        std::env::current_dir().ok()?.join(path)
+    };
+    absolute.ancestors().find_map(|ancestor| {
+        ancestor
+            .join("assets/project.ron")
+            .is_file()
+            .then(|| ancestor.to_path_buf())
+    })
+}
+
+fn visit_scene(
+    path: &Path,
+    project_root: &Path,
+    visiting: &mut Vec<PathBuf>,
+    visited: &mut HashSet<PathBuf>,
+    scene_ids: &mut HashMap<String, PathBuf>,
+) -> Result<(), String> {
+    if let Some(cycle_start) = visiting.iter().position(|candidate| candidate == path) {
+        let mut cycle: Vec<String> = visiting[cycle_start..]
+            .iter()
+            .map(|candidate| project_label(candidate, project_root))
+            .collect();
+        cycle.push(project_label(path, project_root));
+        return Err(format!("cyclic subscene reference: {}", cycle.join(" -> ")));
+    }
+    if !visited.insert(path.to_path_buf()) {
+        return Ok(());
+    }
+
+    let text = std::fs::read_to_string(path)
+        .map_err(|error| format!("could not read {}: {error}", path.display()))?;
+    let document = SceneDocument::from_ron_text(&text)
+        .map_err(|error| format!("{}: {error}", path.display()))?;
+    let Some(composition) = document.composition else {
+        return Ok(());
+    };
+    validate_scene_composition(&composition)
+        .map_err(|error| format!("{}: {error}", path.display()))?;
+    if let Some(existing) = scene_ids.insert(composition.scene_id.clone(), path.to_path_buf()) {
+        if existing != path {
+            return Err(format!(
+                "duplicate scene_id `{}` in {} and {}",
+                composition.scene_id,
+                existing.display(),
+                path.display()
+            ));
+        }
+    }
+
+    visiting.push(path.to_path_buf());
+    for reference in composition.subscenes {
+        let target = canonical_project_path(project_root, &reference.path)?;
+        visit_scene(&target, project_root, visiting, visited, scene_ids)?;
+    }
+    visiting.pop();
+    Ok(())
+}
+
+fn canonical_project_path(project_root: &Path, relative: &str) -> Result<PathBuf, String> {
+    validate_project_relative_path(relative)?;
+    let target = project_root.join(relative);
+    let target = canonical_existing(&target).map_err(|error| {
+        format!(
+            "missing subscene `{relative}` under {}: {error}",
+            project_root.display()
+        )
+    })?;
+    if !target.starts_with(project_root) {
+        return Err(format!("subscene `{relative}` escapes the project root"));
+    }
+    Ok(target)
+}
+
+fn validate_project_relative_path(path: &str) -> Result<(), String> {
+    let path = Path::new(path);
+    if path.as_os_str().is_empty() || path.is_absolute() {
+        return Err(format!(
+            "subscene path `{}` must be project-relative",
+            path.display()
+        ));
+    }
+    if path.components().any(|component| {
+        matches!(
+            component,
+            Component::ParentDir | Component::RootDir | Component::Prefix(_)
+        )
+    }) {
+        return Err(format!(
+            "subscene path `{}` may not escape the project root",
+            path.display()
+        ));
+    }
+    if !path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| name.ends_with(".scn.ron"))
+    {
+        return Err(format!(
+            "subscene path `{}` must name a .scn.ron file",
+            path.display()
+        ));
+    }
+    Ok(())
+}
+
+fn canonical_existing(path: &Path) -> Result<PathBuf, String> {
+    path.canonicalize()
+        .map_err(|error| format!("{}: {error}", path.display()))
+}
+
+fn project_label(path: &Path, project_root: &Path) -> String {
+    path.strip_prefix(project_root)
+        .unwrap_or(path)
+        .display()
+        .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static NEXT_FIXTURE: AtomicU64 = AtomicU64::new(1);
+
+    fn fixture_root() -> PathBuf {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-composition-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        fs::create_dir_all(root.join("assets/levels")).unwrap();
+        fs::write(root.join("assets/project.ron"), "()").unwrap();
+        root
+    }
+
+    fn scene(scene_id: &str, references: &[(&str, &str)]) -> String {
+        let refs = references
+            .iter()
+            .map(|(id, path)| format!("(id:\"{id}\",path:\"{path}\",visible:true,locked:true)"))
+            .collect::<Vec<_>>()
+            .join(",");
+        format!(
+            "(schema_version:2,resources:{{\"shared::components::SceneComposition\":(scene_id:\"{scene_id}\",subscenes:[{refs}])}},entities:{{}})"
+        )
+    }
+
+    #[test]
+    fn valid_two_subscene_graph_passes() {
+        let root = fixture_root();
+        let main = root.join("assets/levels/main.scn.ron");
+        fs::write(
+            &main,
+            scene(
+                "main",
+                &[
+                    ("geometry", "assets/levels/geometry.scn.ron"),
+                    ("lighting", "assets/levels/lighting.scn.ron"),
+                ],
+            ),
+        )
+        .unwrap();
+        fs::write(
+            root.join("assets/levels/geometry.scn.ron"),
+            scene("geometry", &[]),
+        )
+        .unwrap();
+        fs::write(
+            root.join("assets/levels/lighting.scn.ron"),
+            scene("lighting", &[]),
+        )
+        .unwrap();
+
+        validate_composition_graph(&main, &root).unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn missing_and_cyclic_references_are_rejected() {
+        let root = fixture_root();
+        let main = root.join("assets/levels/main.scn.ron");
+        fs::write(
+            &main,
+            scene("main", &[("missing", "assets/levels/missing.scn.ron")]),
+        )
+        .unwrap();
+        assert!(validate_composition_graph(&main, &root)
+            .unwrap_err()
+            .contains("missing subscene"));
+
+        let child = root.join("assets/levels/child.scn.ron");
+        fs::write(
+            &main,
+            scene("main", &[("child", "assets/levels/child.scn.ron")]),
+        )
+        .unwrap();
+        fs::write(
+            &child,
+            scene("child", &[("main", "assets/levels/main.scn.ron")]),
+        )
+        .unwrap();
+        assert!(validate_composition_graph(&main, &root)
+            .unwrap_err()
+            .contains("cyclic subscene reference"));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn unsafe_paths_and_duplicate_reference_ids_are_rejected() {
+        let mut composition = SceneComposition {
+            scene_id: "main".to_string(),
+            subscenes: vec![
+                shared::SubsceneReference {
+                    id: "same".to_string(),
+                    path: "../outside.scn.ron".to_string(),
+                    ..Default::default()
+                },
+                shared::SubsceneReference {
+                    id: "same".to_string(),
+                    path: "assets/levels/other.scn.ron".to_string(),
+                    ..Default::default()
+                },
+            ],
+        };
+        assert!(validate_scene_composition(&composition).is_err());
+        composition.subscenes[0].path = "assets/levels/one.scn.ron".to_string();
+        assert!(validate_scene_composition(&composition)
+            .unwrap_err()
+            .contains("duplicate subscene id"));
+    }
+}
diff --git a/crates/scene/src/document.rs b/crates/scene/src/document.rs
index e27d844..ef96eee 100644
--- a/crates/scene/src/document.rs
+++ b/crates/scene/src/document.rs
@@ -8,6 +8,7 @@ use std::collections::BTreeMap;
 
 use ron::ser::PrettyConfig;
 use serde::{Deserialize, Serialize};
+use shared::{ActorId, PrefabInstance, PrefabRef, SceneComposition};
 
 use crate::{
     migrate_scene_text, read_schema_version, stamp_schema_version, strip_schema_version,
@@ -18,23 +19,37 @@ use crate::{
 pub struct SceneDocument {
     pub schema_version: u32,
     pub entities: Vec<SceneEntity>,
+    pub composition: Option<SceneComposition>,
+    pub resource_types: Vec<String>,
+    pub prefab_instances: Vec<PrefabInstance>,
+    pub prefab_refs: Vec<PrefabRef>,
     normalized_ron: String,
+    resources: BTreeMap<String, String>,
+    source_keys: BTreeMap<SceneEntityId, u64>,
 }
 
 impl SceneDocument {
     pub fn from_ron_text(text: &str) -> Result<Self, String> {
         let normalized = migrate_scene_text(text)?;
         validate_scene_authoring_only(&normalized)?;
+        validate_hierarchy_references(&normalized)?;
         let body = strip_schema_version(&normalized)?;
         let parsed: DynamicSceneBody = ron::from_str(&body)
             .map_err(|err| format!("could not parse scene document body: {err}"))?;
+        let (resources, mut raw_entities) = extract_raw_scene_values(&normalized)?;
 
+        let composition = extract_scene_composition(&parsed.resources)?;
+        let resource_types = parsed.resources.keys().cloned().collect();
+        let prefab_instances = extract_prefab_instances(&parsed.entities)?;
+        let prefab_refs = extract_prefab_refs(&parsed.entities)?;
         let mut entities = Vec::with_capacity(parsed.entities.len());
-        for (index, (_source_key, entity)) in parsed.entities.into_iter().enumerate() {
-            let components = entity
-                .components
+        let mut source_keys = BTreeMap::new();
+        for (index, (source_key, _entity)) in parsed.entities.into_iter().enumerate() {
+            let components = raw_entities
+                .remove(&source_key)
+                .ok_or_else(|| format!("scene entity `{source_key}` has no lossless syntax node"))?
                 .into_iter()
-                .map(|(type_name, value)| SceneComponentBlob::from_value(type_name, value))
+                .map(|(type_name, ron)| SceneComponentBlob::from_ron(type_name, ron))
                 .collect::<Result<Vec<_>, _>>()?;
 
             let actor_id = extract_actor_id(&components);
@@ -45,23 +60,93 @@ impl SceneDocument {
                 .unwrap_or_else(|| SceneEntityId::Anonymous(format!("anonymous:{index}")));
 
             entities.push(SceneEntity {
-                document_id,
+                document_id: document_id.clone(),
                 actor_id,
                 name,
                 parent_actor_id: None,
                 components,
             });
+            source_keys.insert(document_id, source_key);
+        }
+
+        let key_to_actor: BTreeMap<u64, String> = entities
+            .iter()
+            .filter_map(|entity| {
+                let source_key = source_keys.get(&entity.document_id).copied()?;
+                Some((source_key, entity.actor_id.clone()?))
+            })
+            .collect();
+        for entity in &mut entities {
+            entity.parent_actor_id = entity
+                .components
+                .iter()
+                .find(|component| component.type_name == CHILD_OF_COMPONENT)
+                .and_then(|component| parse_child_of_source_key(&component.ron))
+                .and_then(|source_key| key_to_actor.get(&source_key).cloned());
         }
 
         Ok(Self {
             schema_version: read_schema_version(&normalized),
             entities,
+            composition,
+            resource_types,
+            prefab_instances,
+            prefab_refs,
             normalized_ron: normalized,
+            resources,
+            source_keys,
         })
     }
 
     pub fn to_ron_text(&self) -> Result<String, String> {
-        stamp_schema_version(&self.normalized_ron)
+        let mut resources = self.resources.clone();
+        match &self.composition {
+            Some(composition) => {
+                let composition_ron = ron::to_string(composition)
+                    .map_err(|error| format!("could not encode scene composition: {error}"))?;
+                resources.insert(SCENE_COMPOSITION_RESOURCE.to_string(), composition_ron);
+            }
+            None => {
+                resources.remove(SCENE_COMPOSITION_RESOURCE);
+            }
+        }
+
+        let mut used_keys: std::collections::HashSet<u64> =
+            self.source_keys.values().copied().collect();
+        let mut next_key = used_keys
+            .iter()
+            .copied()
+            .max()
+            .unwrap_or(0)
+            .saturating_add(1);
+        let mut entities = BTreeMap::new();
+        for entity in &self.entities {
+            let source_key = self
+                .source_keys
+                .get(&entity.document_id)
+                .copied()
+                .unwrap_or_else(|| {
+                    while used_keys.contains(&next_key) {
+                        next_key = next_key.saturating_add(1);
+                    }
+                    let assigned = next_key;
+                    used_keys.insert(assigned);
+                    next_key = next_key.saturating_add(1);
+                    assigned
+                });
+            let components = entity
+                .components
+                .iter()
+                .map(|component| {
+                    ron::from_str::<ron::Value>(&component.ron).map_err(|error| {
+                        format!("invalid component RON `{}`: {error}", component.type_name)
+                    })?;
+                    Ok((component.type_name.clone(), component.ron.clone()))
+                })
+                .collect::<Result<BTreeMap<_, _>, String>>()?;
+            entities.insert(source_key, components);
+        }
+        encode_lossless_scene_body(&resources, &entities)
     }
 
     pub fn normalized_ron(&self) -> &str {
@@ -108,28 +193,109 @@ impl SceneDocument {
                         entity.document_id
                     ));
                 }
+                let next_key = self
+                    .source_keys
+                    .values()
+                    .copied()
+                    .max()
+                    .unwrap_or(0)
+                    .saturating_add(1);
+                self.source_keys
+                    .insert(entity.document_id.clone(), next_key);
                 self.entities.push(entity);
             }
             ScenePatch::DeleteEntity { target } => {
-                let before = self.entities.len();
-                self.entities.retain(|entity| entity.document_id != target);
-                if self.entities.len() == before {
+                let Some(target_actor_id) = self
+                    .find_entity(&target)
+                    .and_then(|entity| entity.actor_id.clone())
+                else {
                     return Err(format!("scene entity `{target}` not found"));
+                };
+                let mut removed_actor_ids = std::collections::HashSet::from([target_actor_id]);
+                let mut changed = true;
+                while changed {
+                    changed = false;
+                    for entity in &self.entities {
+                        if entity
+                            .parent_actor_id
+                            .as_ref()
+                            .is_some_and(|parent| removed_actor_ids.contains(parent))
+                        {
+                            if let Some(actor_id) = entity.actor_id.clone() {
+                                changed |= removed_actor_ids.insert(actor_id);
+                            }
+                        }
+                    }
+                }
+                let removed_ids: Vec<_> = self
+                    .entities
+                    .iter()
+                    .filter(|entity| {
+                        entity
+                            .actor_id
+                            .as_ref()
+                            .is_some_and(|actor_id| removed_actor_ids.contains(actor_id))
+                    })
+                    .map(|entity| entity.document_id.clone())
+                    .collect();
+                self.entities
+                    .retain(|entity| !removed_ids.contains(&entity.document_id));
+                for removed in removed_ids {
+                    self.source_keys.remove(&removed);
                 }
             }
             ScenePatch::Reparent {
                 target,
                 parent_actor_id,
             } => {
+                let parent_source_key = parent_actor_id
+                    .as_ref()
+                    .map(|parent| {
+                        self.source_keys
+                            .get(&SceneEntityId::ActorId(parent.clone()))
+                            .copied()
+                            .ok_or_else(|| format!("parent actor `{parent}` not found"))
+                    })
+                    .transpose()?;
                 let entity = self
                     .find_entity_mut(&target)
                     .ok_or_else(|| format!("scene entity `{target}` not found"))?;
+                match parent_source_key {
+                    Some(parent_source_key) => {
+                        let component = SceneComponentBlob::from_ron(
+                            CHILD_OF_COMPONENT,
+                            format!("({parent_source_key})"),
+                        )?;
+                        if let Some(existing) = entity
+                            .components
+                            .iter_mut()
+                            .find(|component| component.type_name == CHILD_OF_COMPONENT)
+                        {
+                            *existing = component;
+                        } else {
+                            entity.components.push(component);
+                        }
+                    }
+                    None => entity
+                        .components
+                        .retain(|component| component.type_name != CHILD_OF_COMPONENT),
+                }
                 entity.parent_actor_id = parent_actor_id;
             }
             ScenePatch::Rename { target, name } => {
                 let entity = self
                     .find_entity_mut(&target)
                     .ok_or_else(|| format!("scene entity `{target}` not found"))?;
+                let component = SceneComponentBlob::from_serializable(NAME_COMPONENT, &name)?;
+                if let Some(existing) = entity
+                    .components
+                    .iter_mut()
+                    .find(|existing| existing.type_name == NAME_COMPONENT)
+                {
+                    *existing = component;
+                } else {
+                    entity.components.push(component);
+                }
                 entity.name = Some(name);
             }
             ScenePatch::SetTransform { target, transform } => {
@@ -203,12 +369,18 @@ impl SceneComponentBlob {
         })
     }
 
-    fn from_value(type_name: String, value: ron::Value) -> Result<Self, String> {
-        let pretty = PrettyConfig::new();
-        let ron = ron::ser::to_string_pretty(&value, pretty)
-            .map_err(|err| format!("could not serialize component value `{type_name}`: {err}"))?;
+    pub fn from_ron(type_name: impl Into<String>, ron: impl Into<String>) -> Result<Self, String> {
+        let type_name = type_name.into();
+        let ron = ron.into();
+        ron::from_str::<ron::Value>(&ron)
+            .map_err(|error| format!("invalid component RON `{type_name}`: {error}"))?;
         Ok(Self { type_name, ron })
     }
+
+    pub fn to_value(&self) -> Result<ron::Value, String> {
+        ron::from_str(&self.ron)
+            .map_err(|error| format!("invalid component RON `{}`: {error}", self.type_name))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -258,22 +430,254 @@ impl Default for SceneTransform {
     }
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct DynamicSceneBody {
+    #[serde(default)]
+    resources: BTreeMap<String, ron::Value>,
     #[serde(default)]
     entities: BTreeMap<u64, DynamicSceneEntity>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct DynamicSceneEntity {
     #[serde(default)]
     components: BTreeMap<String, ron::Value>,
 }
 
 const ACTOR_ID_COMPONENT: &str = "shared::components::ActorId";
+const CHILD_OF_COMPONENT: &str = "bevy_ecs::hierarchy::ChildOf";
 const NAME_COMPONENT: &str = "bevy_ecs::name::Name";
+const SCENE_COMPOSITION_RESOURCE: &str = "shared::components::SceneComposition";
+const PREFAB_INSTANCE_COMPONENT: &str = "shared::components::PrefabInstance";
+const PREFAB_REF_COMPONENT: &str = "shared::components::PrefabRef";
 pub const TRANSFORM_COMPONENT: &str = "bevy_transform::components::transform::Transform";
 
+type RawSceneEntities = BTreeMap<u64, BTreeMap<String, String>>;
+
+fn extract_raw_scene_values(
+    text: &str,
+) -> Result<(BTreeMap<String, String>, RawSceneEntities), String> {
+    let file = ron_edit::File::try_from(text)
+        .map_err(|error| format!("could not parse lossless scene syntax: {error}"))?;
+    let root = as_struct(&file.value.content, "scene root")?;
+    let resources = as_map(struct_field(root, "resources")?, "scene resources")?;
+    let entities = as_map(struct_field(root, "entities")?, "scene entities")?;
+
+    let resources = resources
+        .0
+        .values
+        .iter()
+        .map(|entry| {
+            Ok((
+                parse_string_key(&entry.content.key)?,
+                entry.content.value.content.to_string(),
+            ))
+        })
+        .collect::<Result<BTreeMap<_, _>, String>>()?;
+    let entities = entities
+        .0
+        .values
+        .iter()
+        .map(|entry| {
+            let source_key = entry
+                .content
+                .key
+                .to_string()
+                .parse::<u64>()
+                .map_err(|error| format!("invalid scene entity key: {error}"))?;
+            let entity = as_struct(&entry.content.value.content, "scene entity")?;
+            let components = as_map(struct_field(entity, "components")?, "entity components")?;
+            let components = components
+                .0
+                .values
+                .iter()
+                .map(|component| {
+                    Ok((
+                        parse_string_key(&component.content.key)?,
+                        component.content.value.content.to_string(),
+                    ))
+                })
+                .collect::<Result<BTreeMap<_, _>, String>>()?;
+            Ok((source_key, components))
+        })
+        .collect::<Result<BTreeMap<_, _>, String>>()?;
+    Ok((resources, entities))
+}
+
+fn as_struct<'a, 's>(
+    value: &'a ron_edit::Value<'s>,
+    label: &str,
+) -> Result<&'a ron_edit::Struct<'s>, String> {
+    match value {
+        ron_edit::Value::Struct(value) => Ok(value),
+        _ => Err(format!("{label} must be a RON struct")),
+    }
+}
+
+fn as_map<'a, 's>(
+    value: &'a ron_edit::Value<'s>,
+    label: &str,
+) -> Result<&'a ron_edit::Map<'s>, String> {
+    match value {
+        ron_edit::Value::Map(value) => Ok(value),
+        _ => Err(format!("{label} must be a RON map")),
+    }
+}
+
+fn struct_field<'a, 's>(
+    value: &'a ron_edit::Struct<'s>,
+    name: &str,
+) -> Result<&'a ron_edit::Value<'s>, String> {
+    value
+        .fields
+        .values
+        .iter()
+        .find(|field| field.content.key == name)
+        .map(|field| &field.content.value.content)
+        .ok_or_else(|| format!("RON struct is missing `{name}`"))
+}
+
+fn parse_string_key(value: &ron_edit::Value<'_>) -> Result<String, String> {
+    ron::from_str(&value.to_string()).map_err(|error| format!("invalid string map key: {error}"))
+}
+
+fn parse_child_of_source_key(text: &str) -> Option<u64> {
+    let value = ron::from_str::<ron::Value>(text).ok()?;
+    parse_child_of_source_key_value(&value)
+}
+
+fn parse_child_of_source_key_value(value: &ron::Value) -> Option<u64> {
+    let ron::Value::Seq(values) = value else {
+        return None;
+    };
+    let ron::Value::Number(ron::value::Number::Integer(value)) = values.first()? else {
+        return None;
+    };
+    u64::try_from(*value).ok()
+}
+
+pub(crate) fn validate_hierarchy_references(text: &str) -> Result<(), String> {
+    let body = strip_schema_version(text)?;
+    let parsed: DynamicSceneBody = ron::from_str(&body)
+        .map_err(|error| format!("could not parse scene hierarchy: {error}"))?;
+    let mut parents = BTreeMap::new();
+
+    for (entity_key, entity) in &parsed.entities {
+        let Some(value) = entity.components.get(CHILD_OF_COMPONENT) else {
+            continue;
+        };
+        let parent_key = parse_child_of_source_key_value(value).ok_or_else(|| {
+            format!("scene entity `{entity_key}` has a malformed `{CHILD_OF_COMPONENT}` value")
+        })?;
+        if !parsed.entities.contains_key(&parent_key) {
+            return Err(format!(
+                "scene entity `{entity_key}` references missing hierarchy parent `{parent_key}`"
+            ));
+        }
+        parents.insert(*entity_key, parent_key);
+    }
+
+    for start in parents.keys().copied() {
+        let mut visited = std::collections::BTreeSet::new();
+        let mut current = start;
+        while let Some(parent) = parents.get(&current).copied() {
+            if !visited.insert(current) {
+                return Err(format!(
+                    "scene hierarchy contains a cycle involving entity `{current}`"
+                ));
+            }
+            current = parent;
+        }
+    }
+
+    Ok(())
+}
+
+fn encode_lossless_scene_body(
+    resources: &BTreeMap<String, String>,
+    entities: &BTreeMap<u64, BTreeMap<String, String>>,
+) -> Result<String, String> {
+    let mut body = String::from("(resources: {\n");
+    for (type_name, value) in resources {
+        ron::from_str::<ron::Value>(value)
+            .map_err(|error| format!("invalid resource RON `{type_name}`: {error}"))?;
+        body.push_str("        ");
+        body.push_str(
+            &ron::to_string(type_name)
+                .map_err(|error| format!("could not encode resource type: {error}"))?,
+        );
+        body.push_str(": ");
+        body.push_str(value);
+        body.push_str(",\n");
+    }
+    body.push_str("    },\n    entities: {\n");
+    for (source_key, components) in entities {
+        body.push_str(&format!("        {source_key}: (components: {{\n"));
+        for (type_name, value) in components {
+            body.push_str("            ");
+            body.push_str(
+                &ron::to_string(type_name)
+                    .map_err(|error| format!("could not encode component type: {error}"))?,
+            );
+            body.push_str(": ");
+            body.push_str(value);
+            body.push_str(",\n");
+        }
+        body.push_str("        }),\n");
+    }
+    body.push_str("    },\n)");
+    stamp_schema_version(&body)
+}
+
+fn extract_scene_composition(
+    resources: &BTreeMap<String, ron::Value>,
+) -> Result<Option<SceneComposition>, String> {
+    let mut matches = resources
+        .iter()
+        .filter(|(type_name, _)| type_name.as_str() == SCENE_COMPOSITION_RESOURCE);
+    let Some((_type_name, value)) = matches.next() else {
+        return Ok(None);
+    };
+    if matches.next().is_some() {
+        return Err("scene contains multiple composition resources".to_string());
+    }
+    value
+        .clone()
+        .into_rust::<SceneComposition>()
+        .map(Some)
+        .map_err(|error| format!("could not parse scene composition: {error}"))
+}
+
+fn extract_prefab_instances(
+    entities: &BTreeMap<u64, DynamicSceneEntity>,
+) -> Result<Vec<PrefabInstance>, String> {
+    entities
+        .values()
+        .filter_map(|entity| entity.components.get(PREFAB_INSTANCE_COMPONENT))
+        .map(|value| {
+            value
+                .clone()
+                .into_rust::<PrefabInstance>()
+                .map_err(|error| format!("could not parse prefab instance: {error}"))
+        })
+        .collect()
+}
+
+fn extract_prefab_refs(
+    entities: &BTreeMap<u64, DynamicSceneEntity>,
+) -> Result<Vec<PrefabRef>, String> {
+    entities
+        .values()
+        .filter_map(|entity| entity.components.get(PREFAB_REF_COMPONENT))
+        .map(|value| {
+            value
+                .clone()
+                .into_rust::<PrefabRef>()
+                .map_err(|error| format!("could not parse prefab reference: {error}"))
+        })
+        .collect()
+}
+
 fn extract_name(components: &[SceneComponentBlob]) -> Option<String> {
     components
         .iter()
@@ -286,8 +690,10 @@ fn extract_actor_id(components: &[SceneComponentBlob]) -> Option<String> {
     let component = components
         .iter()
         .find(|component| component.type_name == ACTOR_ID_COMPONENT)?;
-    ron::from_str::<String>(&component.ron)
+    ron::from_str::<ActorId>(&component.ron)
         .ok()
+        .map(|id| id.0)
+        .or_else(|| ron::from_str::<String>(&component.ron).ok())
         .or_else(|| {
             ron::from_str::<Vec<String>>(&component.ron)
                 .ok()
@@ -300,6 +706,12 @@ fn extract_actor_id(components: &[SceneComponentBlob]) -> Option<String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn lossless_parser_accepts_anonymous_structs_and_tuples() {
+        let value = "(translation: (1.0, 2.0, 3.0), scale: (1.0, 1.0, 1.0))";
+        assert!(ron_edit::File::try_from(value).is_ok());
+    }
+
     #[test]
     fn parses_scene_document_without_exposing_runtime_entity_ids() {
         let text = r#"(schema_version: 2,
@@ -332,7 +744,10 @@ mod tests {
         let document = SceneDocument::from_ron_text(body).unwrap();
         let text = document.to_ron_text().unwrap();
         assert!(text.starts_with("(schema_version: 2,"));
-        assert!(text.contains("entities: {}"));
+        assert!(SceneDocument::from_ron_text(&text)
+            .unwrap()
+            .entities
+            .is_empty());
     }
 
     #[test]
@@ -372,5 +787,15 @@ mod tests {
             .components
             .iter()
             .any(|component| component.type_name == TRANSFORM_COMPONENT));
+
+        let reparsed = SceneDocument::from_ron_text(&document.to_ron_text().unwrap()).unwrap();
+        let entity = reparsed.find_entity(&target).unwrap();
+        assert_eq!(entity.name.as_deref(), Some("Renamed"));
+        let transform = entity
+            .components
+            .iter()
+            .find(|component| component.type_name == TRANSFORM_COMPONENT)
+            .unwrap();
+        assert!(transform.ron.contains("1.0"));
     }
 }
diff --git a/crates/scene/src/lib.rs b/crates/scene/src/lib.rs
index 98c25cf..4fdd4f8 100644
--- a/crates/scene/src/lib.rs
+++ b/crates/scene/src/lib.rs
@@ -3,17 +3,74 @@
 //! Bevy dynamic scenes are stored as RON tuples. On save the editor stamps
 //! `schema_version` as the first root field; loaders strip it before deserializing.
 
+mod composition;
 pub mod document;
 mod migrate;
+mod prefab;
+mod project_validation;
 
 use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 
+pub use composition::{validate_composition_graph, validate_scene_composition};
 pub use migrate::{migrate_v1_to_v2, DEFAULT_SUN_ILLUMINANCE_LUX};
+pub use prefab::{
+    prefab_graph_revision, validate_prefab_graph, validate_prefab_graph_text,
+    validate_prefab_references, validate_prefab_references_text,
+};
+pub use project_validation::{
+    validate_project, ProjectDependency, ProjectValidationFinding, ProjectValidationReport,
+    ValidationSeverity,
+};
 
 pub const CURRENT_SCENE_SCHEMA_VERSION: u32 = 2;
 
+/// Whether an asset-relative path names a tree excluded from runtime packages.
+pub fn is_runtime_package_excluded_tree(relative: &Path) -> bool {
+    relative
+        .components()
+        .filter_map(|component| match component {
+            std::path::Component::Normal(component) => component.to_str(),
+            _ => None,
+        })
+        .any(|component| {
+            component.starts_with('.')
+                || matches!(
+                    component,
+                    "thumbnails" | "build_profiles" | "recovery" | "autosave"
+                )
+        })
+}
+
+/// Shared validator/packager policy for files that may ship under `assets/`.
+pub fn is_runtime_package_asset(relative: &Path) -> bool {
+    if is_runtime_package_excluded_tree(relative) {
+        return false;
+    }
+    let filename = relative
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or_default()
+        .to_ascii_lowercase();
+    if filename.starts_with('.')
+        || filename.ends_with(".bak")
+        || filename.ends_with(".tmp")
+        || filename.ends_with(".autosave")
+        || filename.ends_with(".recovery")
+    {
+        return false;
+    }
+    !matches!(
+        relative
+            .extension()
+            .and_then(|extension| extension.to_str())
+            .map(str::to_ascii_lowercase)
+            .as_deref(),
+        Some("blend" | "blend1" | "psd" | "kra" | "xcf" | "fbm")
+    )
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SceneSchemaHeader {
     pub schema_version: u32,
@@ -74,7 +131,11 @@ pub fn migrate_scene_text(text: &str) -> Result<String, String> {
     let migrated_body = match version {
         0 | 1 => migrate_v1_to_v2(&body),
         2 => body,
-        _ => body,
+        _ => {
+            return Err(format!(
+                "scene schema version {version} is newer than supported version {CURRENT_SCENE_SCHEMA_VERSION}"
+            ));
+        }
     };
 
     stamp_schema_version(&migrated_body)
@@ -110,6 +171,12 @@ pub const FORBIDDEN_SAVED_COMPONENT_MARKERS: &[&str] = &[
     "bevy_world_serialization::components::WorldAssetRoot",
     "bevy_world_serialization::components::DynamicWorldRoot",
     "bevy_render::visibility::ComputedVisibility",
+    "bevy_audio::",
+    "game::audio::AuthoredAudioVoice",
+    "bevy_animation::AnimationGraphHandle",
+    "bevy_animation::AnimationPlayer",
+    "bevy_animation::AnimationTransitions",
+    "game::animation::AuthoredAnimationRuntime",
 ];
 
 /// Ensures serialized scene text does not contain hydrated ECS component entries.
@@ -131,12 +198,18 @@ pub fn validate_level_text(text: &str) -> Result<(), String> {
     let migrated = migrate_scene_text(text)?;
     strip_schema_version(&migrated)?;
     validate_scene_authoring_only(&migrated)?;
+    document::validate_hierarchy_references(&migrated)?;
     Ok(())
 }
 
 pub fn validate_level_file(path: &Path) -> Result<(), String> {
     let text = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
-    validate_level_text(&text)
+    validate_level_text(&text)?;
+    if let Some(project_root) = composition::find_project_root(path) {
+        validate_composition_graph(path, &project_root)?;
+        validate_prefab_references(path, &project_root)?;
+    }
+    Ok(())
 }
 
 #[cfg(test)]
@@ -159,6 +232,37 @@ mod tests {
         assert!(migrated.contains("schema_version: 2"));
     }
 
+    #[test]
+    fn newer_scene_schema_is_rejected_instead_of_downstamped() {
+        let future = "(schema_version: 999, resources: {}, entities: {})";
+        let error = migrate_scene_text(future).unwrap_err();
+        assert!(error.contains("newer than supported"), "{error}");
+        assert!(validate_level_text(future).is_err());
+    }
+
+    #[test]
+    fn runtime_package_policy_excludes_editor_trees_and_source_formats() {
+        for excluded in [
+            ".index/registry.ron",
+            ".env/secret",
+            "build_profiles/release.ron",
+            "levels/recovery/main.scn.ron",
+            "textures/source.psd",
+            "models/source.blend",
+            "levels/main.scn.ron.bak",
+        ] {
+            assert!(!is_runtime_package_asset(Path::new(excluded)), "{excluded}");
+        }
+        for included in [
+            "project.ron",
+            "levels/main.scn.ron",
+            "textures/albedo.png",
+            "models/mesh.glb",
+        ] {
+            assert!(is_runtime_package_asset(Path::new(included)), "{included}");
+        }
+    }
+
     #[test]
     #[ignore = "run manually to rewrite assets/levels/editor_scene.scn.ron"]
     fn migrate_editor_scene_on_disk() {
@@ -177,6 +281,22 @@ mod tests {
         validate_scene_authoring_only(&text).expect("editor scene must be authoring-only");
     }
 
+    #[test]
+    fn runtime_audio_components_are_rejected_from_authored_scenes() {
+        for marker in [
+            "bevy_audio::audio::AudioPlayer",
+            "bevy_audio::sinks::SpatialAudioSink",
+            "game::audio::AuthoredAudioVoice",
+        ] {
+            let text =
+                format!("(resources: {{}}, entities: {{1:(components:{{\"{marker}\":()}})}})");
+            assert!(
+                validate_scene_authoring_only(&text).is_err(),
+                "{marker} must be runtime-only"
+            );
+        }
+    }
+
     #[test]
     fn v1_scene_gains_actor_kind_on_migrate() {
         let v1 = "(schema_version: 1,(resources: {}, entities: {
@@ -194,4 +314,20 @@ mod tests {
         assert!(migrated.contains("ActorKind"));
         assert!(migrated.contains("StaticMesh"));
     }
+
+    #[test]
+    fn hierarchy_validation_rejects_missing_parent_and_cycles() {
+        let missing_parent = r#"(schema_version: 2, resources: {}, entities: {
+            1: (components: { "bevy_ecs::hierarchy::ChildOf": (99) }),
+        })"#;
+        let error = validate_level_text(missing_parent).unwrap_err();
+        assert!(error.contains("missing hierarchy parent `99`"));
+
+        let cycle = r#"(schema_version: 2, resources: {}, entities: {
+            1: (components: { "bevy_ecs::hierarchy::ChildOf": (2) }),
+            2: (components: { "bevy_ecs::hierarchy::ChildOf": (1) }),
+        })"#;
+        let error = validate_level_text(cycle).unwrap_err();
+        assert!(error.contains("scene hierarchy contains a cycle"));
+    }
 }
diff --git a/crates/scene/src/migrate.rs b/crates/scene/src/migrate.rs
index 5fb3b4e..b2ec340 100644
--- a/crates/scene/src/migrate.rs
+++ b/crates/scene/src/migrate.rs
@@ -105,6 +105,12 @@ fn infer_kind_from_block(block: &str) -> &'static str {
     {
         return actor_kind_ron(ActorKind::PrefabAnchor);
     }
+    if block.contains("\"shared::components::AudioSourceDesc\"") {
+        return actor_kind_ron(ActorKind::AudioSource);
+    }
+    if block.contains("\"shared::components::AudioListenerDesc\"") {
+        return actor_kind_ron(ActorKind::AudioListener);
+    }
     actor_kind_ron(ActorKind::Empty)
 }
 
@@ -122,6 +128,8 @@ fn actor_kind_ron(kind: ActorKind) -> &'static str {
         ActorKind::PostProcessVolume => "PostProcessVolume",
         ActorKind::TeamSpawn => "TeamSpawn",
         ActorKind::Objective => "Objective",
+        ActorKind::AudioSource => "AudioSource",
+        ActorKind::AudioListener => "AudioListener",
     }
 }
 
@@ -233,6 +241,33 @@ mod tests {
         assert!(migrated.contains("Brush"));
     }
 
+    #[test]
+    fn backfills_actor_kind_for_audio_source_entity() {
+        let body = r#"(
+  resources: {},
+  entities: {
+    1: (
+      components: {
+        "shared::components::LevelObject": (),
+        "shared::components::AudioSourceDesc": (
+          clip: None,
+          gain_db: 0.0,
+          pitch: 1.0,
+          looping: false,
+          autoplay: true,
+          spatial_blend: 1.0,
+          attenuation: (min_distance: 1.0, max_distance: 25.0, rolloff: Inverse, rolloff_factor: 1.0),
+          bus: "sfx",
+        ),
+      },
+    ),
+  },
+)"#;
+        let migrated = migrate_v1_to_v2(body);
+        assert!(migrated.contains("ActorKind"));
+        assert!(migrated.contains("AudioSource"));
+    }
+
     #[test]
     fn fixes_low_directional_lux() {
         let body = r#"(
diff --git a/crates/scene/src/prefab.rs b/crates/scene/src/prefab.rs
new file mode 100644
index 0000000..7dba59e
--- /dev/null
+++ b/crates/scene/src/prefab.rs
@@ -0,0 +1,628 @@
+//! Stable prefab dependency validation for nested instances and variants.
+
+use std::collections::{BTreeMap, HashSet};
+use std::path::{Component, Path, PathBuf};
+
+use crate::document::SceneDocument;
+
+pub fn validate_prefab_graph(entry: &Path, project_root: &Path) -> Result<(), String> {
+    let requested = entry.to_path_buf();
+    let entry = canonical_existing(entry)
+        .map_err(|error| format!("missing prefab source `{}`: {error}", requested.display()))?;
+    let project_root = canonical_existing(project_root)?;
+    let text = std::fs::read_to_string(&entry)
+        .map_err(|error| format!("could not read {}: {error}", entry.display()))?;
+    validate_prefab_graph_text(&text, &entry, &project_root)
+}
+
+pub fn validate_prefab_references(entry: &Path, project_root: &Path) -> Result<(), String> {
+    let entry = canonical_existing(entry)?;
+    let project_root = canonical_existing(project_root)?;
+    let text = std::fs::read_to_string(&entry)
+        .map_err(|error| format!("could not read {}: {error}", entry.display()))?;
+    validate_prefab_references_text(&text, &entry, &project_root)
+}
+
+pub fn prefab_graph_revision(entry: &Path, project_root: &Path) -> Result<String, String> {
+    validate_prefab_graph(entry, project_root)?;
+    let entry = canonical_existing(entry)?;
+    let project_root = canonical_existing(project_root)?;
+    let mut files = BTreeMap::new();
+    collect_prefab_graph_files(&entry, &project_root, &mut files)?;
+
+    let mut hash = 0xcbf2_9ce4_8422_2325_u64;
+    for (path, bytes) in files {
+        for byte in path.as_bytes().iter().chain([0xff].iter()).chain(&bytes) {
+            hash ^= u64::from(*byte);
+            hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
+        }
+    }
+    Ok(format!("fnv1a64:{hash:016x}"))
+}
+
+fn collect_prefab_graph_files(
+    path: &Path,
+    project_root: &Path,
+    files: &mut BTreeMap<String, Vec<u8>>,
+) -> Result<(), String> {
+    let label = project_label(path, project_root);
+    if files.contains_key(&label) {
+        return Ok(());
+    }
+    let bytes = std::fs::read(path)
+        .map_err(|error| format!("could not read {}: {error}", path.display()))?;
+    let text = std::str::from_utf8(&bytes)
+        .map_err(|error| format!("{} is not UTF-8: {error}", path.display()))?;
+    let document = SceneDocument::from_ron_text(text)
+        .map_err(|error| format!("{}: {error}", path.display()))?;
+    let mut dependencies: Vec<String> = document
+        .prefab_instances
+        .into_iter()
+        .map(|instance| instance.source_path)
+        .collect();
+    dependencies.sort();
+    dependencies.dedup();
+    files.insert(label, bytes);
+    for source_path in dependencies {
+        let target = resolve_source_path(project_root, &source_path)?;
+        collect_prefab_graph_files(&target, project_root, files)?;
+    }
+    Ok(())
+}
+
+pub fn validate_prefab_graph_text(
+    entry_text: &str,
+    entry: &Path,
+    project_root: &Path,
+) -> Result<(), String> {
+    validate_prefab_graph_text_inner(entry_text, entry, project_root, true)
+}
+
+pub fn validate_prefab_references_text(
+    entry_text: &str,
+    entry: &Path,
+    project_root: &Path,
+) -> Result<(), String> {
+    validate_prefab_graph_text_inner(entry_text, entry, project_root, false)
+}
+
+fn validate_prefab_graph_text_inner(
+    entry_text: &str,
+    entry: &Path,
+    project_root: &Path,
+    require_stable_ids: bool,
+) -> Result<(), String> {
+    let project_root = canonical_existing(project_root)?;
+    let entry = canonical_or_nearest_existing(entry)?;
+    if !entry.starts_with(&project_root) {
+        return Err(format!(
+            "prefab document {} is outside project root {}",
+            entry.display(),
+            project_root.display()
+        ));
+    }
+    let relative_entry = entry
+        .strip_prefix(&project_root)
+        .map_err(|_| "prefab document is outside the project root".to_string())?;
+    validate_entry_path(relative_entry, require_stable_ids)?;
+
+    let mut visiting = Vec::new();
+    let mut visited = HashSet::new();
+    visit_prefab_text(
+        &entry,
+        entry_text,
+        &project_root,
+        &mut visiting,
+        &mut visited,
+        require_stable_ids,
+    )
+}
+
+fn visit_prefab_text(
+    path: &Path,
+    text: &str,
+    project_root: &Path,
+    visiting: &mut Vec<PathBuf>,
+    visited: &mut HashSet<PathBuf>,
+    require_stable_ids: bool,
+) -> Result<(), String> {
+    if let Some(cycle_start) = visiting.iter().position(|candidate| candidate == path) {
+        let mut cycle: Vec<String> = visiting[cycle_start..]
+            .iter()
+            .map(|candidate| project_label(candidate, project_root))
+            .collect();
+        cycle.push(project_label(path, project_root));
+        return Err(format!("cyclic prefab reference: {}", cycle.join(" -> ")));
+    }
+    if !visited.insert(path.to_path_buf()) {
+        return Ok(());
+    }
+
+    let document = SceneDocument::from_ron_text(text)
+        .map_err(|error| format!("{}: {error}", path.display()))?;
+    if require_stable_ids {
+        if !document.resource_types.is_empty() {
+            return Err(format!(
+                "{}: prefab documents may not contain resources ({})",
+                path.display(),
+                document.resource_types.join(", ")
+            ));
+        }
+        validate_actor_ids(&document, path)?;
+        validate_prefab_link_anchors(&document, path)?;
+    }
+    for instance in &document.prefab_instances {
+        shared::decode_prefab_overrides(instance).map_err(|error| {
+            format!(
+                "{}: prefab instance `{}` has invalid overrides: {error}",
+                path.display(),
+                instance.asset_id
+            )
+        })?;
+    }
+    let instance_paths: HashSet<String> = document
+        .prefab_instances
+        .iter()
+        .map(|instance| instance.source_path.clone())
+        .collect();
+    let legacy_refs: Vec<_> = document
+        .prefab_refs
+        .into_iter()
+        .filter(|prefab_ref| !instance_paths.contains(&prefab_ref.path))
+        .collect();
+    if require_stable_ids && !legacy_refs.is_empty() {
+        return Err(format!(
+            "{} contains legacy PrefabRef links without PrefabInstance identity",
+            path.display()
+        ));
+    }
+    let mut dependencies: Vec<(String, String)> = document
+        .prefab_instances
+        .into_iter()
+        .map(|instance| (instance.asset_id, instance.source_path))
+        .collect();
+    dependencies.extend(
+        legacy_refs
+            .into_iter()
+            .map(|prefab_ref| (format!("legacy:{}", prefab_ref.path), prefab_ref.path)),
+    );
+
+    visiting.push(path.to_path_buf());
+    for (asset_id, source_path) in dependencies {
+        if asset_id.trim().is_empty() {
+            return Err(format!(
+                "{}: prefab instance has an empty asset_id",
+                path.display()
+            ));
+        }
+        validate_source_path(&source_path)?;
+        let lexical_target = project_root.join(&source_path);
+        if let Some(cycle_start) = visiting
+            .iter()
+            .position(|candidate| candidate == &lexical_target)
+        {
+            let mut cycle: Vec<String> = visiting[cycle_start..]
+                .iter()
+                .map(|candidate| project_label(candidate, project_root))
+                .collect();
+            cycle.push(project_label(&lexical_target, project_root));
+            return Err(format!("cyclic prefab reference: {}", cycle.join(" -> ")));
+        }
+        let target = resolve_source_path(project_root, &source_path)?;
+        if let Some(cycle_start) = visiting.iter().position(|candidate| candidate == &target) {
+            let mut cycle: Vec<String> = visiting[cycle_start..]
+                .iter()
+                .map(|candidate| project_label(candidate, project_root))
+                .collect();
+            cycle.push(project_label(&target, project_root));
+            return Err(format!("cyclic prefab reference: {}", cycle.join(" -> ")));
+        }
+        if visited.contains(&target) {
+            continue;
+        }
+        let target_text = std::fs::read_to_string(&target).map_err(|error| {
+            format!(
+                "missing prefab source `{}` referenced by {}: {error}",
+                source_path,
+                project_label(path, project_root)
+            )
+        })?;
+        visit_prefab_text(&target, &target_text, project_root, visiting, visited, true)?;
+    }
+    visiting.pop();
+    Ok(())
+}
+
+fn validate_prefab_link_anchors(document: &SceneDocument, path: &Path) -> Result<(), String> {
+    const LEVEL_OBJECT: &str = "shared::components::LevelObject";
+    const PREFAB_INSTANCE: &str = "shared::components::PrefabInstance";
+    const PREFAB_REF: &str = "shared::components::PrefabRef";
+    const ACTOR_KIND: &str = "shared::components::ActorKind";
+    const TRANSFORM: &str = "bevy_transform::components::transform::Transform";
+
+    for entity in &document.entities {
+        let has = |type_name: &str| {
+            entity
+                .components
+                .iter()
+                .any(|component| component.type_name == type_name)
+        };
+        if !has(PREFAB_INSTANCE) && !has(PREFAB_REF) {
+            continue;
+        }
+        let label = entity
+            .actor_id
+            .as_deref()
+            .unwrap_or("anonymous prefab link");
+        for (component, description) in [
+            (LEVEL_OBJECT, "LevelObject"),
+            (TRANSFORM, "Transform"),
+            (ACTOR_KIND, "ActorKind"),
+        ] {
+            if !has(component) {
+                return Err(format!(
+                    "{}: prefab link `{label}` is missing required {description}",
+                    path.display()
+                ));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn validate_actor_ids(document: &SceneDocument, path: &Path) -> Result<(), String> {
+    let mut ids = HashSet::new();
+    for entity in &document.entities {
+        let authored_actor = entity
+            .components
+            .iter()
+            .any(|component| component.type_name == "shared::components::LevelObject");
+        if authored_actor && entity.actor_id.is_none() {
+            return Err(format!(
+                "{} contains an authored prefab actor without ActorId",
+                path.display()
+            ));
+        }
+        let Some(actor_id) = entity.actor_id.as_deref() else {
+            continue;
+        };
+        if !ids.insert(actor_id) {
+            return Err(format!(
+                "{} contains duplicate ActorId `{actor_id}`",
+                path.display()
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn resolve_source_path(project_root: &Path, source_path: &str) -> Result<PathBuf, String> {
+    validate_source_path(source_path)?;
+    let target = project_root.join(source_path);
+    let target = canonical_existing(&target).map_err(|error| {
+        format!(
+            "missing prefab source `{source_path}` under {}: {error}",
+            project_root.display()
+        )
+    })?;
+    if !target.starts_with(project_root) {
+        return Err(format!(
+            "prefab source `{source_path}` escapes the project root"
+        ));
+    }
+    Ok(target)
+}
+
+fn validate_source_path(source_path: &str) -> Result<(), String> {
+    let path = Path::new(source_path);
+    if path.as_os_str().is_empty() || path.is_absolute() {
+        return Err(format!(
+            "prefab source `{}` must be project-relative",
+            path.display()
+        ));
+    }
+    if path.components().any(|component| {
+        matches!(
+            component,
+            Component::ParentDir | Component::RootDir | Component::Prefix(_)
+        )
+    }) {
+        return Err(format!(
+            "prefab source `{}` may not escape the project root",
+            path.display()
+        ));
+    }
+    let components: Vec<_> = path.components().collect();
+    if components.first() != Some(&Component::Normal("assets".as_ref()))
+        || components.get(1) != Some(&Component::Normal("prefabs".as_ref()))
+    {
+        return Err(format!(
+            "prefab source `{}` must be under assets/prefabs/",
+            path.display()
+        ));
+    }
+    if !path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| name.ends_with(".scn.ron"))
+    {
+        return Err(format!(
+            "prefab source `{}` must name a .scn.ron file",
+            path.display()
+        ));
+    }
+    Ok(())
+}
+
+fn validate_entry_path(path: &Path, strict_prefab: bool) -> Result<(), String> {
+    let text = path.to_string_lossy();
+    if strict_prefab {
+        validate_source_path(&text)
+    } else {
+        if path.components().any(|component| {
+            matches!(
+                component,
+                Component::ParentDir | Component::RootDir | Component::Prefix(_)
+            )
+        }) || path.components().next() != Some(Component::Normal("assets".as_ref()))
+        {
+            return Err(format!(
+                "scene document `{}` must remain under assets/",
+                path.display()
+            ));
+        }
+        if !path
+            .file_name()
+            .and_then(|name| name.to_str())
+            .is_some_and(|name| name.ends_with(".scn.ron"))
+        {
+            return Err(format!(
+                "scene document `{}` must name a .scn.ron file",
+                path.display()
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn absolute_lexical(path: &Path) -> Result<PathBuf, String> {
+    if path.is_absolute() {
+        Ok(path.to_path_buf())
+    } else {
+        std::env::current_dir()
+            .map(|cwd| cwd.join(path))
+            .map_err(|error| format!("could not resolve {}: {error}", path.display()))
+    }
+}
+
+fn canonical_or_nearest_existing(path: &Path) -> Result<PathBuf, String> {
+    let absolute = absolute_lexical(path)?;
+    let mut ancestor = absolute.as_path();
+    let mut suffix = Vec::new();
+    loop {
+        match ancestor.canonicalize() {
+            Ok(mut canonical) => {
+                for component in suffix.iter().rev() {
+                    canonical.push(component);
+                }
+                return Ok(canonical);
+            }
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+                let Some(name) = ancestor.file_name() else {
+                    return Err(format!("{}: {error}", path.display()));
+                };
+                suffix.push(name.to_os_string());
+                let Some(parent) = ancestor.parent() else {
+                    return Err(format!("{}: {error}", path.display()));
+                };
+                ancestor = parent;
+            }
+            Err(error) => return Err(format!("{}: {error}", path.display())),
+        }
+    }
+}
+
+fn canonical_existing(path: &Path) -> Result<PathBuf, String> {
+    path.canonicalize()
+        .map_err(|error| format!("{}: {error}", path.display()))
+}
+
+fn project_label(path: &Path, project_root: &Path) -> String {
+    path.strip_prefix(project_root)
+        .unwrap_or(path)
+        .display()
+        .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static NEXT_FIXTURE: AtomicU64 = AtomicU64::new(1);
+
+    fn fixture_root() -> PathBuf {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-prefab-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        fs::create_dir_all(root.join("assets/prefabs")).unwrap();
+        fs::write(root.join("assets/project.ron"), "()").unwrap();
+        root
+    }
+
+    fn prefab(actor_id: &str, references: &[(&str, &str)]) -> String {
+        let actor_components = |id: &str| {
+            format!(
+                "\"shared::components::LevelObject\":(),\"shared::components::ActorId\":(\"{id}\"),\"shared::components::ActorKind\":PrefabAnchor,\"bevy_transform::components::transform::Transform\":(translation:(0.0,0.0,0.0),rotation:(0.0,0.0,0.0,1.0),scale:(1.0,1.0,1.0))"
+            )
+        };
+        let components = references
+            .iter()
+            .enumerate()
+            .map(|(index, (asset_id, path))| {
+                let actor_id = format!("{actor_id}-{index}");
+                format!(
+                    "{}:(components:{{{},\"shared::components::PrefabInstance\":(asset_id:\"{asset_id}\",source_path:\"{path}\",overrides_ron:None)}})",
+                    index + 1,
+                    actor_components(&actor_id)
+                )
+            })
+            .collect::<Vec<_>>()
+            .join(",");
+        let root = if references.is_empty() {
+            format!("1:(components:{{{}}})", actor_components(actor_id))
+        } else {
+            components
+        };
+        format!("(schema_version:2,resources:{{}},entities:{{{root}}})")
+    }
+
+    #[test]
+    fn nested_prefab_graph_passes() {
+        let root = fixture_root();
+        let chair = root.join("assets/prefabs/chair.scn.ron");
+        let room = root.join("assets/prefabs/room.scn.ron");
+        fs::write(&chair, prefab("chair", &[])).unwrap();
+        fs::write(
+            &room,
+            prefab("room", &[("chair-asset", "assets/prefabs/chair.scn.ron")]),
+        )
+        .unwrap();
+
+        validate_prefab_graph(&room, &root).unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn nested_instance_with_invalid_override_payload_is_rejected() {
+        let root = fixture_root();
+        let base = root.join("assets/prefabs/base.scn.ron");
+        let outer = root.join("assets/prefabs/outer.scn.ron");
+        fs::write(&base, prefab("base", &[])).unwrap();
+        let mut instance = shared::PrefabInstance::new("base", "assets/prefabs/base.scn.ron");
+        instance.overrides_ron = Some("not valid override ron".to_string());
+        let text = format!(
+            "(schema_version:2,resources:{{}},entities:{{1:(components:{{\"shared::components::LevelObject\":(),\"shared::components::ActorId\":(\"nested\"),\"shared::components::ActorKind\":PrefabAnchor,\"bevy_transform::components::transform::Transform\":(translation:(0.0,0.0,0.0),rotation:(0.0,0.0,0.0,1.0),scale:(1.0,1.0,1.0)),\"shared::components::PrefabInstance\":{}}})}})",
+            ron::to_string(&instance).unwrap()
+        );
+        fs::write(&outer, text).unwrap();
+
+        let error = validate_prefab_graph(&outer, &root).unwrap_err();
+        assert!(error.contains("invalid overrides"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn graph_revision_changes_when_nested_base_changes() {
+        let root = fixture_root();
+        let base = root.join("assets/prefabs/base.scn.ron");
+        let variant = root.join("assets/prefabs/variant.scn.ron");
+        fs::write(&base, prefab("base-a", &[])).unwrap();
+        fs::write(
+            &variant,
+            prefab("variant", &[("base", "assets/prefabs/base.scn.ron")]),
+        )
+        .unwrap();
+        let before = prefab_graph_revision(&variant, &root).unwrap();
+
+        fs::write(&base, prefab("base-b", &[])).unwrap();
+        let after = prefab_graph_revision(&variant, &root).unwrap();
+
+        assert_ne!(before, after);
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn missing_and_cyclic_sources_are_rejected() {
+        let root = fixture_root();
+        let a = root.join("assets/prefabs/a.scn.ron");
+        let b = root.join("assets/prefabs/b.scn.ron");
+        fs::write(&a, prefab("a", &[("b", "assets/prefabs/b.scn.ron")])).unwrap();
+        let error = validate_prefab_graph(&a, &root).unwrap_err();
+        assert!(error.contains("missing prefab source"), "{error}");
+
+        fs::write(&b, prefab("b", &[("a", "assets/prefabs/a.scn.ron")])).unwrap();
+        let error = validate_prefab_graph(&a, &root).unwrap_err();
+        assert!(error.contains("cyclic prefab reference"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn virtual_variant_cycle_and_unsafe_path_are_rejected() {
+        let root = fixture_root();
+        let variant_path = root.join("assets/prefabs/variant.scn.ron");
+        let text = prefab("variant", &[("self", "assets/prefabs/variant.scn.ron")]);
+        let error = validate_prefab_graph_text(&text, &variant_path, &root).unwrap_err();
+        assert!(error.contains("cyclic prefab reference"), "{error}");
+
+        let text = prefab("unsafe", &[("escape", "../outside.scn.ron")]);
+        let error = validate_prefab_graph_text(&text, &variant_path, &root).unwrap_err();
+        assert!(error.contains("may not escape"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn duplicate_actor_ids_are_rejected() {
+        let root = fixture_root();
+        let prefab_path = root.join("assets/prefabs/duplicate.scn.ron");
+        let text = concat!(
+            "(schema_version:2,resources:{},entities:{",
+            "1:(components:{\"shared::components::LevelObject\":(),",
+            "\"shared::components::ActorId\":(\"same-actor\")}),",
+            "2:(components:{\"shared::components::LevelObject\":(),",
+            "\"shared::components::ActorId\":(\"same-actor\")})",
+            "})"
+        );
+
+        let error = validate_prefab_graph_text(text, &prefab_path, &root).unwrap_err();
+
+        assert!(error.contains("duplicate ActorId `same-actor`"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn symlink_alias_cycle_is_rejected() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let real = root.join("assets/prefabs/real.scn.ron");
+        let alias = root.join("assets/prefabs/alias.scn.ron");
+        fs::write(
+            &real,
+            prefab("real", &[("alias", "assets/prefabs/alias.scn.ron")]),
+        )
+        .unwrap();
+        symlink("real.scn.ron", &alias).unwrap();
+
+        let error = validate_prefab_graph(&real, &root).unwrap_err();
+        assert!(error.contains("cyclic prefab reference"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn new_prefab_path_cannot_escape_through_symlink_parent() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let outside = std::env::temp_dir().join(format!(
+            "blacksite-prefab-outside-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        fs::create_dir_all(&outside).unwrap();
+        fs::remove_dir(root.join("assets/prefabs")).unwrap();
+        symlink(&outside, root.join("assets/prefabs")).unwrap();
+
+        let output = root.join("assets/prefabs/escaped.scn.ron");
+        let error = validate_prefab_graph_text(&prefab("safe", &[]), &output, &root).unwrap_err();
+        assert!(error.contains("outside project root"), "{error}");
+
+        fs::remove_dir_all(root).unwrap();
+        fs::remove_dir_all(outside).unwrap();
+    }
+}
diff --git a/crates/scene/src/project_validation.rs b/crates/scene/src/project_validation.rs
new file mode 100644
index 0000000..d66b6ef
--- /dev/null
+++ b/crates/scene/src/project_validation.rs
@@ -0,0 +1,3178 @@
+//! Authoritative project content validation shared by editor and headless tooling.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::io::Read;
+use std::path::{Component, Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+use shared::{
+    animation_clip_source_index, animation_clip_sub_asset_id, animation_skeleton_source_index,
+    animation_skeleton_sub_asset_id,
+    brush_math::{validate_brush, BrushDiagnosticSeverity},
+    AnimationControllerDesc, AnimationDiagnosticSeverity, AnimationManifest, AudioListenerDesc,
+    AudioSourceDesc, BrushDesc, ColliderDesc, ColliderShapeDesc, EditorAssetRef, MaterialAsset,
+    MaterialDesc, MaterialOverride, ModelRef, PostProcessEffectAsset, PostProcessVolumeDesc,
+    PrefabInstance, PrefabRef, ShaderSchemaAsset, StaticMeshRenderer,
+    ANIMATION_MANIFEST_SCHEMA_VERSION, AUDIO_CLIP_SUB_ASSET_ID,
+    COMPONENT_ANIMATION_CONTROLLER_DESC,
+};
+
+use crate::document::{SceneComponentBlob, SceneDocument};
+
+const MODEL_REF: &str = "shared::components::ModelRef";
+const MATERIAL_DESC: &str = "shared::components::MaterialDesc";
+const MATERIAL_OVERRIDE: &str = "shared::components::MaterialOverride";
+const STATIC_MESH_RENDERER: &str = "shared::components::StaticMeshRenderer";
+const BRUSH_DESC: &str = "shared::components::BrushDesc";
+const COLLIDER_DESC: &str = "shared::components::ColliderDesc";
+const POST_PROCESS_VOLUME: &str = "shared::components::PostProcessVolumeDesc";
+const PREFAB_INSTANCE: &str = "shared::components::PrefabInstance";
+const PREFAB_REF: &str = "shared::components::PrefabRef";
+const AUDIO_SOURCE_DESC: &str = "shared::components::AudioSourceDesc";
+const AUDIO_LISTENER_DESC: &str = "shared::components::AudioListenerDesc";
+const GIT_LFS_POINTER_HEADER_LF: &[u8] = b"version https://git-lfs.github.com/spec/v1\n";
+const GIT_LFS_POINTER_HEADER_CRLF: &[u8] = b"version https://git-lfs.github.com/spec/v1\r\n";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ValidationSeverity {
+    Error,
+    Warning,
+    Info,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProjectDependency {
+    pub owner_path: String,
+    pub owner_actor_id: Option<String>,
+    pub kind: String,
+    pub reference: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProjectValidationFinding {
+    pub severity: ValidationSeverity,
+    pub code: String,
+    pub source_path: String,
+    pub owner_actor_id: Option<String>,
+    pub reference: Option<String>,
+    pub message: String,
+    pub repair: String,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ProjectValidationReport {
+    pub dependencies: Vec<ProjectDependency>,
+    pub findings: Vec<ProjectValidationFinding>,
+}
+
+impl ProjectValidationReport {
+    pub fn blocking_error_count(&self) -> usize {
+        self.findings
+            .iter()
+            .filter(|finding| finding.severity == ValidationSeverity::Error)
+            .count()
+    }
+
+    pub fn is_release_ready(&self) -> bool {
+        self.blocking_error_count() == 0
+    }
+}
+
+/// Validates every authored scene/prefab and returns a stable dependency/finding report.
+pub fn validate_project(project_root: &Path) -> ProjectValidationReport {
+    let mut report = ProjectValidationReport::default();
+    let audio_settings = validate_project_manifest(project_root, &mut report).unwrap_or_default();
+    let mut animation_catalog = validate_asset_registry(project_root, &mut report);
+    validate_material_assets(project_root, &mut report);
+    validate_shader_assets(project_root, &mut report);
+    validate_post_process_assets(project_root, &mut report);
+    validate_static_mesh_manifests(project_root, &mut report);
+    validate_animation_manifests(project_root, &mut report, &mut animation_catalog);
+    let mut files = Vec::new();
+    collect_scene_files(
+        project_root,
+        &project_root.join("assets/levels"),
+        &mut files,
+        &mut report,
+    );
+    collect_scene_files(
+        project_root,
+        &project_root.join("assets/prefabs"),
+        &mut files,
+        &mut report,
+    );
+    files.sort();
+
+    for path in files {
+        validate_document(
+            project_root,
+            &path,
+            &audio_settings,
+            &animation_catalog,
+            &mut report,
+        );
+    }
+
+    report.dependencies.sort_by(|left, right| {
+        (
+            &left.owner_path,
+            &left.owner_actor_id,
+            &left.kind,
+            &left.reference,
+        )
+            .cmp(&(
+                &right.owner_path,
+                &right.owner_actor_id,
+                &right.kind,
+                &right.reference,
+            ))
+    });
+    report.dependencies.dedup();
+    report.findings.sort_by(|left, right| {
+        (
+            &left.source_path,
+            &left.owner_actor_id,
+            &left.code,
+            &left.reference,
+        )
+            .cmp(&(
+                &right.source_path,
+                &right.owner_actor_id,
+                &right.code,
+                &right.reference,
+            ))
+    });
+    report.findings.dedup();
+    report
+}
+
+fn collect_scene_files(
+    project_root: &Path,
+    root: &Path,
+    files: &mut Vec<PathBuf>,
+    report: &mut ProjectValidationReport,
+) {
+    collect_files(project_root, root, ".scn.ron", files, report);
+}
+
+#[derive(Deserialize)]
+struct ProjectManifestView {
+    version: u32,
+    #[serde(default)]
+    template_version: u32,
+    default_level: String,
+    #[serde(default)]
+    asset_roots: Vec<String>,
+    #[serde(default)]
+    capabilities: Vec<String>,
+    #[serde(default)]
+    audio: settings::AudioSettings,
+}
+
+fn validate_project_manifest(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+) -> Option<settings::AudioSettings> {
+    let path = project_root.join("assets/project.ron");
+    let source = "assets/project.ron";
+    let manifest = parse_document::<ProjectManifestView>(&path, source, "project", report)?;
+    if let Err(error) = manifest.audio.validate() {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.bus_graph_invalid".into(),
+            source_path: source.into(),
+            owner_actor_id: None,
+            reference: None,
+            message: error.to_string(),
+            repair: "Repair the project audio buses so required IDs exist and all parent routes terminate at Master.".into(),
+        });
+    }
+    if manifest.version != 1 || manifest.template_version > 1 {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "project.incompatible_schema".into(),
+            source_path: source.into(),
+            owner_actor_id: None,
+            reference: None,
+            message: format!(
+                "unsupported project version {} / template version {}",
+                manifest.version, manifest.template_version
+            ),
+            repair: "Open the project in a compatible editor or run its project migration.".into(),
+        });
+    }
+    add_reference(
+        project_root,
+        report,
+        source,
+        None,
+        "default_level",
+        &manifest.default_level,
+    );
+    let default_is_audited_level = resolve_reference(project_root, &manifest.default_level)
+        .and_then(|path| {
+            let metadata = std::fs::symlink_metadata(&path).ok()?;
+            if !metadata.is_file()
+                || metadata.file_type().is_symlink()
+                || !path.to_string_lossy().ends_with(".scn.ron")
+            {
+                return None;
+            }
+            path.strip_prefix(project_root.join("assets"))
+                .ok()
+                .map(Path::to_path_buf)
+        })
+        .is_some_and(|relative| relative.starts_with("levels") && relative != Path::new("levels"));
+    if !default_is_audited_level {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "project.default_level_outside_levels".into(),
+            source_path: source.into(),
+            owner_actor_id: None,
+            reference: Some(manifest.default_level.clone()),
+            message: "project default level must be a regular .scn.ron file under assets/levels/ so full dependency validation covers it".into(),
+            repair: "Move the startup scene under assets/levels/, use the .scn.ron format, and update default_level.".into(),
+        });
+    }
+    for asset_root in manifest.asset_roots {
+        match resolve_reference(project_root, &asset_root) {
+            Some(path)
+                if std::fs::symlink_metadata(&path)
+                    .is_ok_and(|metadata| metadata.file_type().is_symlink()) =>
+            {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "asset.symlink_unsupported".into(),
+                    source_path: source.into(),
+                    owner_actor_id: None,
+                    reference: Some(asset_root),
+                    message: "configured asset root is a symlink and cannot be packaged".into(),
+                    repair: "Replace the symlink with a regular project asset directory.".into(),
+                });
+            }
+            Some(path) if path.is_dir() => {}
+            Some(_) => report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "project.missing_asset_root".into(),
+                source_path: source.into(),
+                owner_actor_id: None,
+                reference: Some(asset_root),
+                message: "configured asset root does not exist or is not a directory".into(),
+                repair: "Create the asset directory or remove it from project settings.".into(),
+            }),
+            None => report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "asset.unsafe_path".into(),
+                source_path: source.into(),
+                owner_actor_id: None,
+                reference: Some(asset_root),
+                message: "configured asset root escapes the project".into(),
+                repair: "Choose a project-relative directory under assets/.".into(),
+            }),
+        }
+    }
+    let mut capabilities = BTreeSet::new();
+    for capability in manifest.capabilities {
+        if !capabilities.insert(capability.clone()) {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Warning,
+                code: "project.duplicate_capability".into(),
+                source_path: source.into(),
+                owner_actor_id: None,
+                reference: Some(capability),
+                message: "project capability is listed more than once".into(),
+                repair: "Remove the duplicate project capability tag.".into(),
+            });
+        }
+    }
+    if capabilities.contains("solari") {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Info,
+            code: "platform.ray_tracing_optional".into(),
+            source_path: source.into(),
+            owner_actor_id: None,
+            reference: Some("solari".into()),
+            message: "Solari is enabled; unsupported GPUs will use the forward fallback".into(),
+            repair: "Verify both Solari and forward fallback during target-platform QA.".into(),
+        });
+    }
+    Some(manifest.audio)
+}
+
+#[derive(Deserialize)]
+struct RegistryAssetId(String);
+
+#[derive(Default, Deserialize)]
+struct RegistryImportSettings {
+    #[serde(default)]
+    static_mesh_manifest_path: Option<String>,
+    #[serde(default)]
+    animation_manifest_path: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct RegistryAssetRecord {
+    id: RegistryAssetId,
+    path: String,
+    kind_tag: String,
+    #[serde(default)]
+    import_settings: RegistryImportSettings,
+    #[serde(default)]
+    dependencies: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+struct AnimationRegistryRecord {
+    source_path: String,
+    manifest_path: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+enum AnimationManifestLoad {
+    Valid(Box<AnimationManifest>),
+    Invalid(String),
+}
+
+#[derive(Debug, Default)]
+struct AnimationValidationCatalog {
+    registry_by_id: BTreeMap<String, AnimationRegistryRecord>,
+    manifests_by_path: BTreeMap<String, AnimationManifestLoad>,
+}
+
+fn validate_asset_registry(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+) -> AnimationValidationCatalog {
+    let mut animation_catalog = AnimationValidationCatalog::default();
+    let path = project_root.join("assets/.index/registry.ron");
+    if !path.exists() {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Warning,
+            code: "registry.missing".into(),
+            source_path: "assets/.index/registry.ron".into(),
+            owner_actor_id: None,
+            reference: None,
+            message: "asset registry does not exist".into(),
+            repair: "Open the project in the editor to rebuild the asset registry.".into(),
+        });
+        return animation_catalog;
+    }
+    let Some(records) = parse_document::<Vec<RegistryAssetRecord>>(
+        &path,
+        "assets/.index/registry.ron",
+        "registry",
+        report,
+    ) else {
+        return animation_catalog;
+    };
+    let mut ids = BTreeSet::new();
+    let mut paths = BTreeSet::new();
+    for record in records {
+        if record.id.0.trim().is_empty() || !ids.insert(record.id.0.clone()) {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "registry.duplicate_or_empty_id".into(),
+                source_path: "assets/.index/registry.ron".into(),
+                owner_actor_id: None,
+                reference: Some(record.id.0.clone()),
+                message: "asset registry ID is empty or duplicated".into(),
+                repair: "Reimport the affected asset to assign a unique stable ID.".into(),
+            });
+        }
+        if !paths.insert(record.path.clone()) {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "registry.duplicate_path".into(),
+                source_path: "assets/.index/registry.ron".into(),
+                owner_actor_id: None,
+                reference: Some(record.path.clone()),
+                message: "asset path appears more than once in the registry".into(),
+                repair: "Refresh the asset registry and retain one stable record.".into(),
+            });
+        }
+        let runtime_record = reference_is_runtime_package_asset(&record.path);
+        if runtime_record {
+            add_reference(
+                project_root,
+                report,
+                "assets/.index/registry.ron",
+                None,
+                &format!("registry_{}", record.kind_tag.to_lowercase()),
+                &record.path,
+            );
+            for dependency in &record.dependencies {
+                add_reference(
+                    project_root,
+                    report,
+                    &record.path,
+                    None,
+                    "import_dependency",
+                    dependency,
+                );
+            }
+            if let Some(manifest) = record.import_settings.static_mesh_manifest_path.as_deref() {
+                add_reference(
+                    project_root,
+                    report,
+                    &record.path,
+                    None,
+                    "generated_manifest",
+                    manifest,
+                );
+            }
+            if let Some(manifest) = record.import_settings.animation_manifest_path.as_deref() {
+                add_reference(
+                    project_root,
+                    report,
+                    &record.path,
+                    None,
+                    "animation_manifest",
+                    manifest,
+                );
+            }
+        }
+        if record.kind_tag == "Model" {
+            animation_catalog
+                .registry_by_id
+                .entry(record.id.0.clone())
+                .or_insert(AnimationRegistryRecord {
+                    source_path: record.path.clone(),
+                    manifest_path: record.import_settings.animation_manifest_path.clone(),
+                });
+        }
+        if record.kind_tag == "Model"
+            && !matches!(
+                Path::new(&record.path)
+                    .extension()
+                    .and_then(|extension| extension.to_str())
+                    .map(str::to_ascii_lowercase)
+                    .as_deref(),
+                Some("gltf" | "glb" | "fbx")
+            )
+        {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "import.unsupported_model_format".into(),
+                source_path: "assets/.index/registry.ron".into(),
+                owner_actor_id: None,
+                reference: Some(record.path.clone()),
+                message: "model registry entry uses an unsupported import format".into(),
+                repair: "Convert the model to glTF, GLB, or FBX and reimport it.".into(),
+            });
+        }
+        if record.kind_tag == "AudioClip" && !is_supported_audio_reference(&record.path) {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "import.unsupported_audio_format".into(),
+                source_path: "assets/.index/registry.ron".into(),
+                owner_actor_id: None,
+                reference: Some(record.path.clone()),
+                message: "audio registry entry uses a format not enabled by the runtime".into(),
+                repair: "Convert the clip to Ogg Vorbis, WAV, MP3, or FLAC and reimport it.".into(),
+            });
+        }
+    }
+    animation_catalog
+}
+
+fn reference_is_runtime_package_asset(reference: &str) -> bool {
+    let relative = Path::new(reference.split('#').next().unwrap_or(reference));
+    if relative.is_absolute()
+        || relative.components().any(|component| {
+            matches!(
+                component,
+                Component::ParentDir | Component::RootDir | Component::Prefix(_)
+            )
+        })
+    {
+        return true;
+    }
+    let relative = relative.strip_prefix("assets").unwrap_or(relative);
+    crate::is_runtime_package_asset(relative)
+}
+
+fn validate_material_assets(project_root: &Path, report: &mut ProjectValidationReport) {
+    for path in ron_files(
+        project_root,
+        &project_root.join("assets/materials"),
+        ".ron",
+        report,
+    ) {
+        let source = display_project_path(project_root, &path);
+        let Some(asset) = parse_document::<MaterialAsset>(&path, &source, "material", report)
+        else {
+            continue;
+        };
+        if let Some(shader) = asset.shader {
+            add_reference(
+                project_root,
+                report,
+                &source,
+                None,
+                "shader_schema",
+                &shader,
+            );
+        }
+        collect_material(project_root, report, &source, None, &asset.material);
+    }
+}
+
+fn validate_shader_assets(project_root: &Path, report: &mut ProjectValidationReport) {
+    for path in ron_files(
+        project_root,
+        &project_root.join("assets/shaders"),
+        ".shader.ron",
+        report,
+    ) {
+        let source = display_project_path(project_root, &path);
+        let Some(asset) =
+            parse_document::<ShaderSchemaAsset>(&path, &source, "shader schema", report)
+        else {
+            continue;
+        };
+        if let Some(wgsl) = asset.wgsl_path {
+            add_reference(project_root, report, &source, None, "shader", &wgsl);
+        }
+        for texture in asset.default_textures {
+            if let Some(reference) = texture.texture {
+                collect_asset_ref(project_root, report, &source, None, "texture", &reference);
+            }
+        }
+    }
+}
+
+fn validate_post_process_assets(project_root: &Path, report: &mut ProjectValidationReport) {
+    for path in ron_files(
+        project_root,
+        &project_root.join("assets/post_fx"),
+        ".ron",
+        report,
+    ) {
+        let source = display_project_path(project_root, &path);
+        let Some(asset) =
+            parse_document::<PostProcessEffectAsset>(&path, &source, "post effect", report)
+        else {
+            continue;
+        };
+        add_reference(project_root, report, &source, None, "shader", &asset.shader);
+    }
+}
+
+#[derive(Deserialize)]
+struct StaticMeshManifestView {
+    schema_version: u32,
+    asset_id: String,
+    source: StaticMeshSourceView,
+    #[serde(default)]
+    warnings: Vec<String>,
+}
+
+#[derive(Deserialize)]
+struct StaticMeshSourceView {
+    path: String,
+    #[serde(default)]
+    dependencies: Vec<String>,
+}
+
+fn validate_static_mesh_manifests(project_root: &Path, report: &mut ProjectValidationReport) {
+    for path in ron_files(
+        project_root,
+        &project_root.join("assets/meshes/generated"),
+        ".static_mesh.ron",
+        report,
+    ) {
+        let source = display_project_path(project_root, &path);
+        let Some(manifest) = parse_document::<StaticMeshManifestView>(
+            &path,
+            &source,
+            "static mesh manifest",
+            report,
+        ) else {
+            continue;
+        };
+        if manifest.schema_version != 1 || manifest.asset_id.trim().is_empty() {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "manifest.incompatible_schema".into(),
+                source_path: source.clone(),
+                owner_actor_id: None,
+                reference: None,
+                message: format!(
+                    "unsupported static mesh manifest schema {} or empty asset ID",
+                    manifest.schema_version
+                ),
+                repair: "Reimport the source model to regenerate its static mesh manifest.".into(),
+            });
+        }
+        add_reference(
+            project_root,
+            report,
+            &source,
+            None,
+            "model",
+            &manifest.source.path,
+        );
+        for dependency in manifest.source.dependencies {
+            add_reference(
+                project_root,
+                report,
+                &source,
+                None,
+                "import_dependency",
+                &dependency,
+            );
+        }
+        for warning in manifest.warnings {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Warning,
+                code: "import.unsupported_feature".into(),
+                source_path: source.clone(),
+                owner_actor_id: None,
+                reference: Some(manifest.source.path.clone()),
+                message: warning,
+                repair:
+                    "Review the generated static representation or use Scene Instance placement."
+                        .into(),
+            });
+        }
+    }
+}
+
+fn validate_animation_manifests(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    catalog: &mut AnimationValidationCatalog,
+) {
+    for path in ron_files(
+        project_root,
+        &project_root.join(shared::ANIMATION_ARTIFACT_DIR),
+        ".animation.ron",
+        report,
+    ) {
+        let source = display_project_path(project_root, &path);
+        let load = match std::fs::read_to_string(&path) {
+            Ok(text) => match ron::from_str::<AnimationManifest>(&text) {
+                Ok(manifest) => {
+                    validate_animation_manifest_contract(project_root, report, &source, &manifest);
+                    AnimationManifestLoad::Valid(Box::new(manifest))
+                }
+                Err(error) => {
+                    let message = format!("could not parse animation manifest: {error}");
+                    report.findings.push(ProjectValidationFinding {
+                        severity: ValidationSeverity::Error,
+                        code: "animation.manifest_malformed".into(),
+                        source_path: source.clone(),
+                        owner_actor_id: None,
+                        reference: None,
+                        message: message.clone(),
+                        repair: "Reimport the source model to regenerate the animation manifest."
+                            .into(),
+                    });
+                    AnimationManifestLoad::Invalid(message)
+                }
+            },
+            Err(error) => {
+                let message = format!("could not read animation manifest: {error}");
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "animation.manifest_unreadable".into(),
+                    source_path: source.clone(),
+                    owner_actor_id: None,
+                    reference: None,
+                    message: message.clone(),
+                    repair: "Restore the generated manifest or reimport the source model.".into(),
+                });
+                AnimationManifestLoad::Invalid(message)
+            }
+        };
+        catalog.manifests_by_path.insert(source, load);
+    }
+
+    let registry_records = catalog
+        .registry_by_id
+        .iter()
+        .map(|(asset_id, record)| (asset_id.clone(), record.clone()))
+        .collect::<Vec<_>>();
+    for (asset_id, record) in registry_records {
+        let Some(manifest_path) = record.manifest_path.as_deref() else {
+            continue;
+        };
+        let normalized = normalized_project_reference(manifest_path);
+        let manifest = match catalog.manifests_by_path.get(&normalized) {
+            Some(AnimationManifestLoad::Valid(manifest)) => manifest,
+            Some(AnimationManifestLoad::Invalid(_)) => continue,
+            None => {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "animation.manifest_missing".into(),
+                    source_path: "assets/.index/registry.ron".into(),
+                    owner_actor_id: None,
+                    reference: Some(manifest_path.to_string()),
+                    message: format!(
+                        "registered model `{}` has no readable generated animation manifest",
+                        record.source_path
+                    ),
+                    repair: "Reimport the model to regenerate its UUID-keyed animation manifest."
+                        .into(),
+                });
+                continue;
+            }
+        };
+        if manifest.asset_id != asset_id {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.manifest_asset_mismatch".into(),
+                source_path: normalized.clone(),
+                owner_actor_id: None,
+                reference: Some(asset_id),
+                message: format!(
+                    "registry animation manifest for `{}` declares asset ID `{}`",
+                    record.source_path, manifest.asset_id
+                ),
+                repair: "Reimport the model so its UUID-keyed animation manifest matches the asset registry.".into(),
+            });
+        }
+        if manifest.source.path != record.source_path {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.manifest_source_mismatch".into(),
+                source_path: normalized,
+                owner_actor_id: None,
+                reference: Some(record.source_path),
+                message: format!(
+                    "animation manifest source `{}` does not match its registry model",
+                    manifest.source.path
+                ),
+                repair:
+                    "Reimport the moved model so the generated animation source path is refreshed."
+                        .into(),
+            });
+        }
+    }
+}
+
+fn validate_animation_manifest_contract(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    manifest: &AnimationManifest,
+) {
+    if manifest.schema_version != ANIMATION_MANIFEST_SCHEMA_VERSION
+        || manifest.asset_id.trim().is_empty()
+    {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "animation.manifest_incompatible_schema".into(),
+            source_path: source_path.into(),
+            owner_actor_id: None,
+            reference: Some(manifest.asset_id.clone()),
+            message: format!(
+                "unsupported animation manifest schema {} or empty asset ID",
+                manifest.schema_version
+            ),
+            repair: "Reimport the source model with this editor version to regenerate the animation manifest.".into(),
+        });
+    }
+    let expected_name = format!("{}.animation.ron", manifest.asset_id);
+    if Path::new(source_path)
+        .file_name()
+        .and_then(|name| name.to_str())
+        != Some(expected_name.as_str())
+    {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "animation.manifest_unstable_path".into(),
+            source_path: source_path.into(),
+            owner_actor_id: None,
+            reference: Some(manifest.asset_id.clone()),
+            message: "animation manifest filename is not keyed by its stable registry UUID".into(),
+            repair:
+                "Reimport the source model and remove the incorrectly named generated manifest."
+                    .into(),
+        });
+    }
+
+    let source_format = manifest.source.format.to_ascii_lowercase();
+    let source_extension = Path::new(&manifest.source.path)
+        .extension()
+        .and_then(|extension| extension.to_str())
+        .map(str::to_ascii_lowercase);
+    let source_present = !manifest.source.path.trim().is_empty()
+        && matches!(source_format.as_str(), "gltf" | "glb" | "fbx")
+        && source_extension.as_deref() == Some(source_format.as_str());
+    if !source_present {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "animation.manifest_source_invalid".into(),
+            source_path: source_path.into(),
+            owner_actor_id: None,
+            reference: Some(manifest.source.path.clone()),
+            message: "animation manifest has no supported source path/format, or the format disagrees with the file extension".into(),
+            repair: "Reimport a glTF/GLB animated model or a static FBX model.".into(),
+        });
+    } else {
+        add_reference(
+            project_root,
+            report,
+            source_path,
+            None,
+            "animation_source",
+            &manifest.source.path,
+        );
+    }
+
+    let fingerprint = &manifest.source.fingerprint;
+    let hash_is_present = fingerprint.content_hash.len() == 64
+        && fingerprint
+            .content_hash
+            .bytes()
+            .all(|byte| byte.is_ascii_hexdigit());
+    if fingerprint.byte_len == 0 || fingerprint.modified_unix_secs == 0 || !hash_is_present {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "animation.manifest_fingerprint_missing".into(),
+            source_path: source_path.into(),
+            owner_actor_id: None,
+            reference: Some(manifest.source.path.clone()),
+            message: "animation manifest source fingerprint is incomplete or malformed".into(),
+            repair:
+                "Reimport the source model to regenerate its byte length and BLAKE3 fingerprint."
+                    .into(),
+        });
+    } else if let Some(path) = resolve_reference(project_root, &manifest.source.path) {
+        if let Ok(metadata) = std::fs::metadata(&path) {
+            if metadata.len() != fingerprint.byte_len {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "animation.manifest_stale".into(),
+                    source_path: source_path.into(),
+                    owner_actor_id: None,
+                    reference: Some(manifest.source.path.clone()),
+                    message: format!(
+                        "animation source size changed from {} to {} bytes after import",
+                        fingerprint.byte_len,
+                        metadata.len()
+                    ),
+                    repair: "Reimport the changed model before validation or packaging.".into(),
+                });
+            } else {
+                match blake3_file_hash(&path) {
+                    Ok(content_hash) if content_hash != fingerprint.content_hash => {
+                        report.findings.push(ProjectValidationFinding {
+                            severity: ValidationSeverity::Error,
+                            code: "animation.manifest_stale".into(),
+                            source_path: source_path.into(),
+                            owner_actor_id: None,
+                            reference: Some(manifest.source.path.clone()),
+                            message: "animation source content changed after import even though its byte length is unchanged".into(),
+                            repair: "Reimport the changed model before validation or packaging."
+                                .into(),
+                        });
+                    }
+                    Ok(_) => {}
+                    Err(error) => report.findings.push(ProjectValidationFinding {
+                        severity: ValidationSeverity::Error,
+                        code: "animation.manifest_source_unreadable".into(),
+                        source_path: source_path.into(),
+                        owner_actor_id: None,
+                        reference: Some(manifest.source.path.clone()),
+                        message: format!("could not hash animation source: {error}"),
+                        repair: "Restore readable source content and reimport the model.".into(),
+                    }),
+                }
+            }
+        }
+    }
+    for dependency in &manifest.source.dependencies {
+        add_reference(
+            project_root,
+            report,
+            source_path,
+            None,
+            "animation_import_dependency",
+            dependency,
+        );
+    }
+
+    let mut skeleton_ids = BTreeSet::new();
+    let mut skeleton_indices = BTreeSet::new();
+    for skeleton in &manifest.skeletons {
+        if skeleton.id.trim().is_empty()
+            || !skeleton_ids.insert(skeleton.id.clone())
+            || !skeleton_indices.insert(skeleton.source_index)
+            || animation_skeleton_source_index(&skeleton.id) != Some(skeleton.source_index)
+            || skeleton.id
+                != animation_skeleton_sub_asset_id(skeleton.source_index, &skeleton.label)
+        {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.skeleton_ref_invalid".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(skeleton.id.clone()),
+                message: "skeleton sub-asset ID/index is empty, duplicated, or not deterministically derived from its source label".into(),
+                repair: "Reimport the model to regenerate deterministic skeleton sub-asset IDs."
+                    .into(),
+            });
+        }
+        if skeleton.signature.is_empty() || skeleton.joint_paths.is_empty() {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.skeleton_signature_missing".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(skeleton.id.clone()),
+                message: "skeleton has no exact signature or ordered joint paths".into(),
+                repair: "Re-export a valid skin with joints and reimport the glTF/GLB model."
+                    .into(),
+            });
+        }
+    }
+
+    let mut clip_ids = BTreeSet::new();
+    let mut clip_indices = BTreeSet::new();
+    for clip in &manifest.clips {
+        if clip.id.trim().is_empty()
+            || !clip_ids.insert(clip.id.clone())
+            || !clip_indices.insert(clip.source_index)
+            || animation_clip_source_index(&clip.id) != Some(clip.source_index)
+            || clip.id != animation_clip_sub_asset_id(clip.source_index, &clip.label)
+        {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.clip_ref_invalid".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(clip.id.clone()),
+                message: "clip sub-asset ID/index is empty, duplicated, or not deterministically derived from its source label".into(),
+                repair: "Reimport the model to regenerate deterministic clip sub-asset IDs.".into(),
+            });
+        }
+        if !clip.duration_seconds.is_finite() || clip.duration_seconds < 0.0 {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.clip_duration_invalid".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(clip.id.clone()),
+                message: "clip duration is negative or non-finite".into(),
+                repair: "Repair the source clip timeline and reimport the model.".into(),
+            });
+        }
+        if clip
+            .target_skeleton_signature
+            .as_ref()
+            .is_some_and(|signature| signature.is_empty())
+        {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.clip_signature_missing".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(clip.id.clone()),
+                message: "clip declares an empty target skeleton signature".into(),
+                repair:
+                    "Re-export the clip with channels targeting one valid skeleton and reimport."
+                        .into(),
+            });
+        }
+        let mut event_ids = BTreeSet::new();
+        for event in &clip.events {
+            if event.id.trim().is_empty()
+                || !event_ids.insert(event.id.clone())
+                || !event.time_seconds.is_finite()
+                || event.time_seconds < 0.0
+                || event.time_seconds > clip.duration_seconds
+            {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "animation.event_invalid".into(),
+                    source_path: source_path.into(),
+                    owner_actor_id: None,
+                    reference: Some(format!("{}#{}", clip.id, event.id)),
+                    message:
+                        "animation event ID is empty/duplicated or its time is outside the clip"
+                            .into(),
+                    repair:
+                        "Give events unique stable IDs inside the clip duration, then reimport."
+                            .into(),
+                });
+            }
+        }
+    }
+
+    match source_format.as_str() {
+        "gltf" | "glb" if !manifest.runtime_supported => {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.runtime_unsupported".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(manifest.source.path.clone()),
+                message: "glTF/GLB animation manifest is unexpectedly marked runtime-unsupported"
+                    .into(),
+                repair: "Reimport the glTF/GLB model with the current animation importer.".into(),
+            });
+        }
+        "fbx"
+            if (!manifest.skeletons.is_empty() || !manifest.clips.is_empty())
+                && !manifest.diagnostics.iter().any(|diagnostic| {
+                    diagnostic.severity == AnimationDiagnosticSeverity::Error
+                        && diagnostic.code == "animation.fbx_runtime_unsupported"
+                }) =>
+        {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "animation.fbx_runtime_unsupported".into(),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: Some(manifest.source.path.clone()),
+                message: "animated/skinned FBX cannot hydrate with the current FBX loader".into(),
+                repair: "Export the animated source as glTF 2.0 (.glb or .gltf) and reimport it."
+                    .into(),
+            });
+        }
+        _ => {}
+    }
+    for diagnostic in &manifest.diagnostics {
+        report.findings.push(ProjectValidationFinding {
+            severity: match diagnostic.severity {
+                AnimationDiagnosticSeverity::Info => ValidationSeverity::Info,
+                AnimationDiagnosticSeverity::Warning => ValidationSeverity::Warning,
+                AnimationDiagnosticSeverity::Error => ValidationSeverity::Error,
+            },
+            code: diagnostic.code.clone(),
+            source_path: source_path.into(),
+            owner_actor_id: None,
+            reference: Some(manifest.source.path.clone()),
+            message: diagnostic.message.clone(),
+            repair: diagnostic.repair.clone(),
+        });
+    }
+}
+
+fn parse_document<T: for<'de> Deserialize<'de>>(
+    path: &Path,
+    source_path: &str,
+    kind: &str,
+    report: &mut ProjectValidationReport,
+) -> Option<T> {
+    let text = match std::fs::read_to_string(path) {
+        Ok(text) => text,
+        Err(error) => {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: format!("{kind}.unreadable").replace(' ', "_"),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: None,
+                message: format!("could not read {kind}: {error}"),
+                repair: "Restore the file or correct its filesystem permissions.".into(),
+            });
+            return None;
+        }
+    };
+    match ron::from_str(&text) {
+        Ok(document) => Some(document),
+        Err(error) => {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: format!("{kind}.invalid").replace(' ', "_"),
+                source_path: source_path.into(),
+                owner_actor_id: None,
+                reference: None,
+                message: format!("could not parse {kind}: {error}"),
+                repair: format!("Repair or regenerate the {kind} document."),
+            });
+            None
+        }
+    }
+}
+
+fn ron_files(
+    project_root: &Path,
+    root: &Path,
+    suffix: &str,
+    report: &mut ProjectValidationReport,
+) -> Vec<PathBuf> {
+    let mut files = Vec::new();
+    collect_files(project_root, root, suffix, &mut files, report);
+    files.sort();
+    files
+}
+
+fn collect_files(
+    project_root: &Path,
+    root: &Path,
+    suffix: &str,
+    files: &mut Vec<PathBuf>,
+    report: &mut ProjectValidationReport,
+) {
+    let metadata = match std::fs::symlink_metadata(root) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return,
+        Err(error) => {
+            push_traversal_finding(project_root, root, error.to_string(), report);
+            return;
+        }
+    };
+    if metadata.file_type().is_symlink() {
+        push_traversal_finding(project_root, root, "asset tree is a symlink".into(), report);
+        return;
+    }
+    if !metadata.is_dir() {
+        return;
+    }
+    let entries = match std::fs::read_dir(root) {
+        Ok(entries) => entries,
+        Err(error) => {
+            push_traversal_finding(project_root, root, error.to_string(), report);
+            return;
+        }
+    };
+    for entry in entries {
+        let entry = match entry {
+            Ok(entry) => entry,
+            Err(error) => {
+                push_traversal_finding(project_root, root, error.to_string(), report);
+                continue;
+            }
+        };
+        let path = entry.path();
+        let file_type = match entry.file_type() {
+            Ok(file_type) => file_type,
+            Err(error) => {
+                push_traversal_finding(project_root, &path, error.to_string(), report);
+                continue;
+            }
+        };
+        if file_type.is_symlink() {
+            push_traversal_finding(
+                project_root,
+                &path,
+                "asset entry is a symlink".into(),
+                report,
+            );
+        } else if file_type.is_dir() {
+            collect_files(project_root, &path, suffix, files, report);
+        } else if path.to_string_lossy().ends_with(suffix) {
+            files.push(path);
+        }
+    }
+}
+
+fn push_traversal_finding(
+    project_root: &Path,
+    path: &Path,
+    message: String,
+    report: &mut ProjectValidationReport,
+) {
+    report.findings.push(ProjectValidationFinding {
+        severity: ValidationSeverity::Error,
+        code: "asset.traversal_failed".into(),
+        source_path: display_project_path(project_root, path),
+        owner_actor_id: None,
+        reference: None,
+        message: format!("could not safely traverse project content: {message}"),
+        repair: "Replace symlinks with regular project files and restore directory read access."
+            .into(),
+    });
+}
+
+fn validate_document(
+    project_root: &Path,
+    path: &Path,
+    audio_settings: &settings::AudioSettings,
+    animation_catalog: &AnimationValidationCatalog,
+    report: &mut ProjectValidationReport,
+) {
+    let source_path = display_project_path(project_root, path);
+    if let Err(error) = crate::validate_level_file(path) {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "scene.invalid".into(),
+            source_path: source_path.clone(),
+            owner_actor_id: None,
+            reference: None,
+            message: error,
+            repair: "Open the source document and repair the reported schema or graph error."
+                .into(),
+        });
+    }
+
+    let text = match std::fs::read_to_string(path) {
+        Ok(text) => text,
+        Err(error) => {
+            report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "scene.unreadable".into(),
+                source_path,
+                owner_actor_id: None,
+                reference: None,
+                message: format!("could not read scene document: {error}"),
+                repair: "Restore the file or correct its filesystem permissions.".into(),
+            });
+            return;
+        }
+    };
+    let Ok(document) = SceneDocument::from_ron_text(&text) else {
+        return;
+    };
+
+    if let Some(composition) = &document.composition {
+        for subscene in &composition.subscenes {
+            add_reference(
+                project_root,
+                report,
+                &source_path,
+                None,
+                "subscene",
+                &subscene.path,
+            );
+        }
+    }
+    let mut enabled_listeners = Vec::new();
+    for entity in &document.entities {
+        for component in &entity.components {
+            if component.type_name == AUDIO_LISTENER_DESC {
+                if let Ok(listener) = ron::from_str::<AudioListenerDesc>(&component.ron) {
+                    if listener.enabled {
+                        enabled_listeners.push((entity.actor_id.clone(), listener.priority));
+                    }
+                }
+            }
+            collect_component_references(
+                project_root,
+                report,
+                &source_path,
+                entity.actor_id.as_deref(),
+                audio_settings,
+                animation_catalog,
+                component,
+            );
+        }
+    }
+    if let Some(highest) = enabled_listeners
+        .iter()
+        .map(|(_, priority)| *priority)
+        .max()
+    {
+        let tied: Vec<_> = enabled_listeners
+            .iter()
+            .filter(|(_, priority)| *priority == highest)
+            .collect();
+        if tied.len() > 1 {
+            for (actor_id, _) in tied {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "audio.listener_priority_tie".into(),
+                    source_path: source_path.clone(),
+                    owner_actor_id: actor_id.clone(),
+                    reference: Some(highest.to_string()),
+                    message: format!(
+                        "multiple enabled audio listeners share the highest priority {highest}"
+                    ),
+                    repair: "Give the intended listener a unique higher priority or disable the alternatives.".into(),
+                });
+            }
+        }
+    }
+}
+
+fn collect_component_references(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    audio_settings: &settings::AudioSettings,
+    animation_catalog: &AnimationValidationCatalog,
+    component: &SceneComponentBlob,
+) {
+    macro_rules! parse {
+        ($ty:ty) => {
+            match ron::from_str::<$ty>(&component.ron) {
+                Ok(value) => value,
+                Err(_) => return,
+            }
+        };
+    }
+    match component.type_name.as_str() {
+        COMPONENT_ANIMATION_CONTROLLER_DESC => {
+            match ron::from_str::<AnimationControllerDesc>(&component.ron) {
+                Ok(controller) => validate_animation_controller(
+                    project_root,
+                    report,
+                    source_path,
+                    actor_id,
+                    &controller,
+                    animation_catalog,
+                ),
+                Err(error) => push_animation_actor_finding(
+                    report,
+                    source_path,
+                    actor_id,
+                    "animation.controller_malformed",
+                    "AnimationControllerDesc",
+                    None,
+                    format!("could not parse AnimationControllerDesc: {error}"),
+                    "Repair the controller component or remove and recreate it in the Inspector.",
+                ),
+            }
+        }
+        MODEL_REF => {
+            let model = parse!(ModelRef);
+            if model.asset_id.trim().is_empty() {
+                add_reference(
+                    project_root,
+                    report,
+                    source_path,
+                    actor_id,
+                    "model",
+                    &model.path,
+                );
+            } else if let Some(record) = animation_catalog.registry_by_id.get(&model.asset_id) {
+                add_reference(
+                    project_root,
+                    report,
+                    source_path,
+                    actor_id,
+                    "model",
+                    &record.source_path,
+                );
+                if normalized_project_reference(&model.path)
+                    != normalized_project_reference(&record.source_path)
+                {
+                    report.findings.push(ProjectValidationFinding {
+                        severity: ValidationSeverity::Warning,
+                        code: "model.cached_path_stale".into(),
+                        source_path: source_path.to_string(),
+                        owner_actor_id: actor_id.map(str::to_string),
+                        reference: Some(model.asset_id),
+                        message: format!(
+                            "ModelRef cached path `{}` differs from registered path `{}`",
+                            model.path, record.source_path
+                        ),
+                        repair: "Open and save the scene to refresh the cached path hint; runtime resolution already uses the stable asset ID.".into(),
+                    });
+                }
+            } else {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "model.asset_unresolved".into(),
+                    source_path: source_path.to_string(),
+                    owner_actor_id: actor_id.map(str::to_string),
+                    reference: Some(model.asset_id),
+                    message: "ModelRef asset ID is absent from the project registry".into(),
+                    repair: "Restore/reimport the owning model or reassign the model reference in the editor.".into(),
+                });
+            }
+        }
+        MATERIAL_DESC => collect_material(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            &parse!(MaterialDesc),
+        ),
+        MATERIAL_OVERRIDE => {
+            for slot in parse!(MaterialOverride).slots {
+                if let Some(reference) = slot.base_material {
+                    collect_asset_ref(
+                        project_root,
+                        report,
+                        source_path,
+                        actor_id,
+                        "material",
+                        &reference,
+                    );
+                }
+                collect_material(project_root, report, source_path, actor_id, &slot.material);
+            }
+        }
+        STATIC_MESH_RENDERER => {
+            for slot in parse!(StaticMeshRenderer).slots {
+                collect_asset_ref(
+                    project_root,
+                    report,
+                    source_path,
+                    actor_id,
+                    "mesh",
+                    &slot.mesh,
+                );
+                if let Some(material) = slot.material {
+                    collect_asset_ref(
+                        project_root,
+                        report,
+                        source_path,
+                        actor_id,
+                        "material",
+                        &material,
+                    );
+                }
+            }
+        }
+        BRUSH_DESC => {
+            let brush = parse!(BrushDesc);
+            for diagnostic in validate_brush(&brush).diagnostics {
+                report.findings.push(ProjectValidationFinding {
+                    severity: match diagnostic.severity {
+                        BrushDiagnosticSeverity::Error => ValidationSeverity::Error,
+                        BrushDiagnosticSeverity::Warning => ValidationSeverity::Warning,
+                    },
+                    code: "brush.invalid".into(),
+                    source_path: source_path.to_string(),
+                    owner_actor_id: actor_id.map(str::to_string),
+                    reference: diagnostic.face.map(|face| face.0),
+                    message: diagnostic.message,
+                    repair: "Repair or rebuild the brush face in Brush Edit mode.".into(),
+                });
+            }
+            for face in brush.faces {
+                if let Some(material) = face.material {
+                    collect_asset_ref(
+                        project_root,
+                        report,
+                        source_path,
+                        actor_id,
+                        "material",
+                        &material,
+                    );
+                }
+                if let Some(texture) = face.texture {
+                    collect_asset_ref(
+                        project_root,
+                        report,
+                        source_path,
+                        actor_id,
+                        "texture",
+                        &texture,
+                    );
+                }
+            }
+        }
+        COLLIDER_DESC => validate_collider(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            &parse!(ColliderDesc),
+        ),
+        POST_PROCESS_VOLUME => {
+            let volume = parse!(PostProcessVolumeDesc);
+            for (kind, path) in [
+                ("post_process", volume.fullscreen_effect),
+                ("rendering_profile", volume.profile),
+            ] {
+                if let Some(path) = path {
+                    add_reference(project_root, report, source_path, actor_id, kind, &path);
+                }
+            }
+        }
+        PREFAB_INSTANCE => add_reference(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            "prefab",
+            &parse!(PrefabInstance).source_path,
+        ),
+        PREFAB_REF => add_reference(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            "prefab",
+            &parse!(PrefabRef).path,
+        ),
+        AUDIO_SOURCE_DESC => validate_audio_source(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            audio_settings,
+            &parse!(AudioSourceDesc),
+        ),
+        AUDIO_LISTENER_DESC => {
+            let listener = parse!(AudioListenerDesc);
+            if !listener.ear_gap.is_finite() || listener.ear_gap <= 0.0 {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "audio.listener_invalid".into(),
+                    source_path: source_path.to_string(),
+                    owner_actor_id: actor_id.map(str::to_string),
+                    reference: Some("ear_gap".into()),
+                    message: "audio listener ear gap must be positive and finite".into(),
+                    repair: "Set ear_gap to a positive distance in meters.".into(),
+                });
+            }
+        }
+        _ => {}
+    }
+}
+
+fn validate_animation_controller(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    controller: &AnimationControllerDesc,
+    catalog: &AnimationValidationCatalog,
+) {
+    if !controller.default_crossfade_seconds.is_finite()
+        || controller.default_crossfade_seconds < 0.0
+    {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.crossfade_invalid",
+            "AnimationControllerDesc.default_crossfade_seconds",
+            Some(controller.default_crossfade_seconds.to_string()),
+            "default animation crossfade must be finite and non-negative",
+            "Set the controller default crossfade to a finite duration of zero or more seconds.",
+        );
+    }
+
+    let skeleton = controller.skeleton.as_ref().and_then(|reference| {
+        let property = "AnimationControllerDesc.skeleton";
+        if animation_skeleton_source_index(&reference.sub_asset_id).is_none() {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.skeleton_ref_invalid",
+                property,
+                Some(stable_animation_reference(reference)),
+                "controller skeleton is not a stable imported skeleton reference",
+                "Select a skeleton sub-asset from the imported glTF/GLB model.",
+            );
+            return None;
+        }
+        let manifest = animation_manifest_for_reference(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            property,
+            reference,
+            "animation_skeleton",
+            catalog,
+        )?;
+        match manifest
+            .skeletons
+            .iter()
+            .find(|skeleton| skeleton.id == reference.sub_asset_id)
+        {
+            Some(skeleton) => Some(skeleton.clone()),
+            None => {
+                push_animation_actor_finding(
+                    report,
+                    source_path,
+                    actor_id,
+                    "animation.skeleton_missing",
+                    property,
+                    Some(stable_animation_reference(reference)),
+                    "controller skeleton sub-asset is missing from its generated manifest",
+                    "Choose an available skeleton or reimport the model to restore the referenced skeleton ID.",
+                );
+                None
+            }
+        }
+    });
+    if controller.skeleton.is_none() {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.skeleton_missing",
+            "AnimationControllerDesc.skeleton",
+            None,
+            "animation controller has no skeleton reference",
+            "Assign the exact imported skeleton used by this animated model.",
+        );
+    }
+
+    if controller.states.is_empty() {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.states_missing",
+            "AnimationControllerDesc.states",
+            None,
+            "animation controller has no named states",
+            "Add at least one named state and assign an imported clip.",
+        );
+    }
+    let mut state_ids = BTreeSet::new();
+    for (index, state) in controller.states.iter().enumerate() {
+        let state_key = if state.id.trim().is_empty() {
+            format!("index {index}")
+        } else {
+            state.id.clone()
+        };
+        let state_property = format!("AnimationControllerDesc.states[{state_key}]");
+        if state.id.trim().is_empty() || !state_ids.insert(state.id.clone()) {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.state_id_invalid",
+                &format!("{state_property}.id"),
+                Some(state.id.clone()),
+                "animation state ID is empty or duplicated",
+                "Give every controller state a unique, stable non-empty ID.",
+            );
+        }
+        if !state.speed.is_finite() || state.speed <= 0.0 {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.speed_invalid",
+                &format!("{state_property}.speed"),
+                Some(state.speed.to_string()),
+                "animation state speed must be positive and finite",
+                "Set playback speed to a finite value greater than zero.",
+            );
+        }
+        if !state.range.start_seconds.is_finite() || state.range.start_seconds < 0.0 {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.range_invalid",
+                &format!("{state_property}.range.start_seconds"),
+                Some(state.range.start_seconds.to_string()),
+                "animation range start must be finite and non-negative",
+                "Set the state range start inside the selected clip.",
+            );
+        }
+        if state
+            .range
+            .end_seconds
+            .is_some_and(|end| !end.is_finite() || end <= state.range.start_seconds)
+        {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.range_invalid",
+                &format!("{state_property}.range.end_seconds"),
+                state.range.end_seconds.map(|end| end.to_string()),
+                "animation range end must be finite and greater than its start",
+                "Set the optional range end after the start and inside the selected clip.",
+            );
+        }
+
+        let clip_property = format!("{state_property}.clip");
+        if animation_clip_source_index(&state.clip.sub_asset_id).is_none() {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.clip_ref_invalid",
+                &clip_property,
+                Some(stable_animation_reference(&state.clip)),
+                "state clip is not a stable imported animation clip reference",
+                "Assign a clip sub-asset from a supported glTF/GLB animation manifest.",
+            );
+            continue;
+        }
+        let Some(manifest) = animation_manifest_for_reference(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            &clip_property,
+            &state.clip,
+            "animation_clip",
+            catalog,
+        ) else {
+            continue;
+        };
+        let Some(clip) = manifest
+            .clips
+            .iter()
+            .find(|clip| clip.id == state.clip.sub_asset_id)
+            .cloned()
+        else {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.clip_missing",
+                &clip_property,
+                Some(stable_animation_reference(&state.clip)),
+                "state clip sub-asset is missing from its generated manifest",
+                "Choose an available clip or reimport the model to restore the referenced clip ID.",
+            );
+            continue;
+        };
+
+        let effective_end = state.range.end_seconds.unwrap_or(clip.duration_seconds);
+        if !effective_end.is_finite()
+            || state.range.start_seconds >= effective_end
+            || effective_end > clip.duration_seconds
+        {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.range_out_of_clip",
+                &format!("{state_property}.range"),
+                Some(format!(
+                    "{}..{} / {}s",
+                    state.range.start_seconds, effective_end, clip.duration_seconds
+                )),
+                "authored playback range falls outside the imported clip duration",
+                "Choose a start/end range within the selected clip, or clear the end to use its duration.",
+            );
+        }
+
+        if let Some(skeleton) = &skeleton {
+            match &clip.target_skeleton_signature {
+                Some(signature) if signature == &skeleton.signature => {}
+                Some(signature) => push_animation_actor_finding(
+                    report,
+                    source_path,
+                    actor_id,
+                    "animation.skeleton_mismatch",
+                    &clip_property,
+                    Some(stable_animation_reference(&state.clip)),
+                    format!(
+                        "clip skeleton signature `{}` does not match controller skeleton `{}`",
+                        signature.0, skeleton.signature.0
+                    ),
+                    "Assign a clip exported for the exact selected skeleton; v1 does not retarget mismatched rigs.",
+                ),
+                None => push_animation_actor_finding(
+                    report,
+                    source_path,
+                    actor_id,
+                    "animation.clip_signature_missing",
+                    &clip_property,
+                    Some(stable_animation_reference(&state.clip)),
+                    "clip has no uniquely resolved target skeleton signature",
+                    "Re-export the clip with channels targeting exactly one skeleton and reimport it.",
+                ),
+            }
+        }
+    }
+
+    if controller.default_state.trim().is_empty()
+        || controller.state(&controller.default_state).is_none()
+    {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.default_state_invalid",
+            "AnimationControllerDesc.default_state",
+            Some(controller.default_state.clone()),
+            "default animation state is empty or does not name an authored state",
+            "Choose one unique state ID as the controller default.",
+        );
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn animation_manifest_for_reference<'a>(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    property: &str,
+    reference: &EditorAssetRef,
+    dependency_kind: &str,
+    catalog: &'a AnimationValidationCatalog,
+) -> Option<&'a AnimationManifest> {
+    if !reference.is_resolved() {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.reference_unresolved",
+            property,
+            Some(stable_animation_reference(reference)),
+            "animation reference has no stable registry asset/sub-asset identity",
+            "Reassign the skeleton or clip from the Asset Browser.",
+        );
+        return None;
+    }
+    report.dependencies.push(ProjectDependency {
+        owner_path: source_path.to_string(),
+        owner_actor_id: actor_id.map(str::to_string),
+        kind: dependency_kind.into(),
+        reference: stable_animation_reference(reference),
+    });
+    let Some(record) = catalog.registry_by_id.get(&reference.asset_id) else {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.asset_unresolved",
+            property,
+            Some(stable_animation_reference(reference)),
+            "animation reference asset ID is absent from the project registry",
+            "Restore/reimport the owning model or reassign this reference to a registered asset.",
+        );
+        return None;
+    };
+    let Some(manifest_path) = record.manifest_path.as_deref() else {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.manifest_missing",
+            property,
+            Some(record.source_path.clone()),
+            "registered model has no generated animation manifest",
+            "Reimport the model to generate its UUID-keyed animation manifest.",
+        );
+        return None;
+    };
+    add_reference(
+        project_root,
+        report,
+        source_path,
+        actor_id,
+        "animation_manifest",
+        manifest_path,
+    );
+    let normalized = normalized_project_reference(manifest_path);
+    let Some(load) = catalog.manifests_by_path.get(&normalized) else {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.manifest_missing",
+            property,
+            Some(manifest_path.to_string()),
+            "generated animation manifest does not exist at the registry path",
+            "Reimport the model to regenerate the missing animation manifest.",
+        );
+        return None;
+    };
+    let manifest = match load {
+        AnimationManifestLoad::Valid(manifest) => manifest,
+        AnimationManifestLoad::Invalid(error) => {
+            push_animation_actor_finding(
+                report,
+                source_path,
+                actor_id,
+                "animation.manifest_malformed",
+                property,
+                Some(manifest_path.to_string()),
+                format!("generated animation manifest is unusable: {error}"),
+                "Reimport the model to replace the malformed generated manifest.",
+            );
+            return None;
+        }
+    };
+    if manifest.asset_id != reference.asset_id {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.manifest_asset_mismatch",
+            property,
+            Some(stable_animation_reference(reference)),
+            format!(
+                "animation manifest declares asset ID `{}` instead of `{}`",
+                manifest.asset_id, reference.asset_id
+            ),
+            "Reimport the owning model and reassign the stable animation reference.",
+        );
+        return None;
+    }
+    let format = manifest.source.format.to_ascii_lowercase();
+    if !manifest.runtime_supported || !matches!(format.as_str(), "gltf" | "glb") {
+        push_animation_actor_finding(
+            report,
+            source_path,
+            actor_id,
+            "animation.runtime_unsupported",
+            property,
+            Some(manifest.source.path.clone()),
+            "controller references animation data that the runtime cannot hydrate",
+            "Export animated content as glTF 2.0 (.glb or .gltf), reimport it, and reassign the reference.",
+        );
+    }
+    Some(manifest)
+}
+
+fn stable_animation_reference(reference: &EditorAssetRef) -> String {
+    format!("{}#{}", reference.asset_id, reference.sub_asset_id)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn push_animation_actor_finding(
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    code: &str,
+    property: &str,
+    value: Option<String>,
+    message: impl Into<String>,
+    repair: impl Into<String>,
+) {
+    let reference = Some(match value {
+        Some(value) if !value.is_empty() => format!("{property}: {value}"),
+        _ => property.to_string(),
+    });
+    report.findings.push(ProjectValidationFinding {
+        severity: ValidationSeverity::Error,
+        code: code.into(),
+        source_path: source_path.into(),
+        owner_actor_id: actor_id.map(str::to_string),
+        reference,
+        message: message.into(),
+        repair: repair.into(),
+    });
+}
+
+fn validate_audio_source(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    audio_settings: &settings::AudioSettings,
+    source: &AudioSourceDesc,
+) {
+    let mut invalid = Vec::new();
+    if !source.gain_db.is_finite()
+        || !(settings::AUDIO_GAIN_DB_MIN..=settings::AUDIO_GAIN_DB_MAX).contains(&source.gain_db)
+    {
+        invalid.push("gain_db");
+    }
+    if !source.pitch.is_finite() || source.pitch <= 0.0 {
+        invalid.push("pitch");
+    }
+    if !source.spatial_blend.is_finite() || !(0.0..=1.0).contains(&source.spatial_blend) {
+        invalid.push("spatial_blend");
+    }
+    if !source.attenuation.min_distance.is_finite()
+        || source.attenuation.min_distance < 0.0
+        || !source.attenuation.max_distance.is_finite()
+        || source.attenuation.max_distance <= source.attenuation.min_distance
+        || !source.attenuation.rolloff_factor.is_finite()
+        || source.attenuation.rolloff_factor < 0.0
+    {
+        invalid.push("attenuation");
+    }
+    for property in invalid {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.source_invalid".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: Some(property.into()),
+            message: format!("audio source property `{property}` is outside its supported range"),
+            repair: "Repair the highlighted audio source property in the Inspector.".into(),
+        });
+    }
+
+    if audio_settings.bus(&source.bus).is_none() {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.bus_unknown".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: Some(source.bus.clone()),
+            message: format!("audio source routes to unknown bus `{}`", source.bus),
+            repair: "Select an existing project audio bus or restore the missing stable bus ID."
+                .into(),
+        });
+    }
+
+    let Some(clip) = source.clip.as_ref() else {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.clip_missing".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: None,
+            message: "audio source has no clip assigned".into(),
+            repair: "Assign a supported audio clip in the Audio Source Inspector.".into(),
+        });
+        return;
+    };
+    if !clip.is_resolved() || clip.sub_asset_id != AUDIO_CLIP_SUB_ASSET_ID {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.clip_reference_invalid".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: clip.source_path.clone(),
+            message: "audio clip reference lacks a stable audio asset identity".into(),
+            repair: "Reassign the clip from the Asset Browser to rebuild its stable reference."
+                .into(),
+        });
+    }
+    let Some(path) = clip.source_path.as_deref() else {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.clip_runtime_path_missing".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: Some(clip.asset_id.clone()),
+            message: "audio clip reference has no standalone runtime path".into(),
+            repair: "Reassign the clip from the Asset Browser to cache its project path.".into(),
+        });
+        return;
+    };
+    if !is_supported_audio_reference(path) {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "audio.codec_unsupported".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: Some(path.to_string()),
+            message: "audio clip format is not enabled by the runtime codec set".into(),
+            repair: "Convert the clip to Ogg Vorbis, WAV, MP3, or FLAC and reassign it.".into(),
+        });
+    }
+    collect_asset_ref(
+        project_root,
+        report,
+        source_path,
+        actor_id,
+        "audio_clip",
+        clip,
+    );
+}
+
+fn is_supported_audio_reference(path: &str) -> bool {
+    Path::new(path)
+        .extension()
+        .and_then(|extension| extension.to_str())
+        .is_some_and(|extension| {
+            matches!(
+                extension.to_ascii_lowercase().as_str(),
+                "ogg" | "oga" | "spx" | "wav" | "mp3" | "flac"
+            )
+        })
+}
+
+fn validate_collider(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    collider: &ColliderDesc,
+) {
+    let invalid = match &collider.shape {
+        ColliderShapeDesc::Cuboid {
+            x_length,
+            y_length,
+            z_length,
+        } => {
+            !x_length.is_finite()
+                || !y_length.is_finite()
+                || !z_length.is_finite()
+                || *x_length <= 0.0
+                || *y_length <= 0.0
+                || *z_length <= 0.0
+        }
+        ColliderShapeDesc::Sphere { radius } => !radius.is_finite() || *radius <= 0.0,
+        ColliderShapeDesc::Capsule { radius, height } => {
+            !radius.is_finite() || !height.is_finite() || *radius <= 0.0 || *height <= 0.0
+        }
+        ColliderShapeDesc::StaticMesh { meshes, .. } => {
+            for mesh in meshes {
+                collect_asset_ref(project_root, report, source_path, actor_id, "mesh", mesh);
+            }
+            meshes.is_empty()
+        }
+    };
+    if invalid {
+        report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "collider.invalid".into(),
+            source_path: source_path.to_string(),
+            owner_actor_id: actor_id.map(str::to_string),
+            reference: None,
+            message: "collider dimensions or mesh references are invalid".into(),
+            repair: "Choose positive finite dimensions or at least one valid static mesh.".into(),
+        });
+    }
+}
+
+fn collect_material(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    material: &MaterialDesc,
+) {
+    let mut paths = Vec::new();
+    paths.extend(
+        material
+            .shader
+            .schema_path
+            .clone()
+            .map(|path| ("shader_schema", path)),
+    );
+    paths.extend(
+        material
+            .shader
+            .shader_path
+            .clone()
+            .map(|path| ("shader", path)),
+    );
+    paths.extend(
+        material
+            .base_color_texture
+            .clone()
+            .map(|path| ("texture", path)),
+    );
+    paths.extend(
+        material
+            .emissive_texture
+            .clone()
+            .map(|path| ("texture", path)),
+    );
+    paths.extend(
+        material
+            .normal_map_texture
+            .clone()
+            .map(|path| ("texture", path)),
+    );
+    paths.extend(
+        material
+            .metallic_roughness_texture
+            .clone()
+            .map(|path| ("texture", path)),
+    );
+    paths.extend(
+        material
+            .material_asset_path
+            .clone()
+            .map(|path| ("material", path)),
+    );
+    for binding in &material.textures {
+        if let Some(reference) = &binding.texture {
+            collect_asset_ref(
+                project_root,
+                report,
+                source_path,
+                actor_id,
+                "texture",
+                reference,
+            );
+        }
+    }
+    for (kind, path) in paths {
+        add_reference(project_root, report, source_path, actor_id, kind, &path);
+    }
+}
+
+fn collect_asset_ref(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    source_path: &str,
+    actor_id: Option<&str>,
+    kind: &str,
+    reference: &shared::EditorAssetRef,
+) {
+    if let Some(path) = reference.source_path.as_deref() {
+        add_reference(project_root, report, source_path, actor_id, kind, path);
+        return;
+    }
+    if !reference.asset_id.trim().is_empty() {
+        add_reference(
+            project_root,
+            report,
+            source_path,
+            actor_id,
+            "generated_manifest",
+            &format!(
+                "assets/meshes/generated/{}.static_mesh.ron",
+                reference.asset_id
+            ),
+        );
+    }
+}
+
+fn add_reference(
+    project_root: &Path,
+    report: &mut ProjectValidationReport,
+    owner_path: &str,
+    owner_actor_id: Option<&str>,
+    kind: &str,
+    reference: &str,
+) {
+    if reference.trim().is_empty() {
+        return;
+    }
+    let dependency = ProjectDependency {
+        owner_path: owner_path.to_string(),
+        owner_actor_id: owner_actor_id.map(str::to_string),
+        kind: kind.to_string(),
+        reference: reference.to_string(),
+    };
+    let resolved = resolve_reference(project_root, reference);
+    report.dependencies.push(dependency);
+    match resolved {
+        Some(path) if path.is_file() => {
+            let relative = path.strip_prefix(project_root.join("assets")).ok();
+            if std::fs::symlink_metadata(&path)
+                .is_ok_and(|metadata| metadata.file_type().is_symlink())
+            {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "asset.symlink_unsupported".into(),
+                    source_path: owner_path.to_string(),
+                    owner_actor_id: owner_actor_id.map(str::to_string),
+                    reference: Some(reference.to_string()),
+                    message: format!(
+                        "referenced {kind} asset `{reference}` is a symlink and cannot be packaged"
+                    ),
+                    repair: "Replace the symlink with a regular project asset file.".into(),
+                });
+            } else if relative.is_none_or(|relative| !crate::is_runtime_package_asset(relative)) {
+                report.findings.push(ProjectValidationFinding {
+                    severity: ValidationSeverity::Error,
+                    code: "asset.not_packageable".into(),
+                    source_path: owner_path.to_string(),
+                    owner_actor_id: owner_actor_id.map(str::to_string),
+                    reference: Some(reference.to_string()),
+                    message: format!(
+                        "referenced {kind} asset `{reference}` is excluded from runtime packages"
+                    ),
+                    repair: "Reference a regular runtime asset outside editor-only trees and convert source-authoring files to a supported runtime format.".into(),
+                });
+            } else {
+                match is_git_lfs_pointer(&path) {
+                    Ok(false) => {}
+                    Ok(true) => report.findings.push(ProjectValidationFinding {
+                severity: ValidationSeverity::Error,
+                code: "asset.git_lfs_object_missing".into(),
+                source_path: owner_path.to_string(),
+                owner_actor_id: owner_actor_id.map(str::to_string),
+                reference: Some(reference.to_string()),
+                message: format!(
+                    "referenced {kind} asset `{reference}` is an unhydrated Git LFS pointer, not runtime content"
+                ),
+                repair: "Run `git lfs pull` in the project checkout, then rerun validation.".into(),
+                    }),
+                    Err(error) => report.findings.push(ProjectValidationFinding {
+                        severity: ValidationSeverity::Error,
+                        code: "asset.unreadable".into(),
+                        source_path: owner_path.to_string(),
+                        owner_actor_id: owner_actor_id.map(str::to_string),
+                        reference: Some(reference.to_string()),
+                        message: format!(
+                            "referenced {kind} asset `{reference}` could not be read: {error}"
+                        ),
+                        repair: "Restore read access to the asset, then rerun validation.".into(),
+                    }),
+                }
+            }
+        }
+        Some(_) => report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "asset.missing".into(),
+            source_path: owner_path.to_string(),
+            owner_actor_id: owner_actor_id.map(str::to_string),
+            reference: Some(reference.to_string()),
+            message: format!("referenced {kind} asset `{reference}` does not exist"),
+            repair: "Restore the asset or update the owning actor/reference.".into(),
+        }),
+        None => report.findings.push(ProjectValidationFinding {
+            severity: ValidationSeverity::Error,
+            code: "asset.unsafe_path".into(),
+            source_path: owner_path.to_string(),
+            owner_actor_id: owner_actor_id.map(str::to_string),
+            reference: Some(reference.to_string()),
+            message: format!("referenced {kind} asset path `{reference}` escapes the project"),
+            repair: "Choose a project-relative asset path under assets/.".into(),
+        }),
+    }
+}
+
+fn is_git_lfs_pointer(path: &Path) -> std::io::Result<bool> {
+    let mut prefix = [0_u8; GIT_LFS_POINTER_HEADER_CRLF.len()];
+    let byte_count = std::fs::File::open(path)?.read(&mut prefix)?;
+    Ok(has_git_lfs_pointer_header(&prefix[..byte_count]))
+}
+
+fn blake3_file_hash(path: &Path) -> std::io::Result<String> {
+    let mut file = std::fs::File::open(path)?;
+    let mut hasher = blake3::Hasher::new();
+    let mut buffer = [0_u8; 64 * 1024];
+    loop {
+        let byte_count = file.read(&mut buffer)?;
+        if byte_count == 0 {
+            break;
+        }
+        hasher.update(&buffer[..byte_count]);
+    }
+    Ok(hasher.finalize().to_hex().to_string())
+}
+
+fn has_git_lfs_pointer_header(bytes: &[u8]) -> bool {
+    bytes.starts_with(GIT_LFS_POINTER_HEADER_LF) || bytes.starts_with(GIT_LFS_POINTER_HEADER_CRLF)
+}
+
+fn resolve_reference(project_root: &Path, reference: &str) -> Option<PathBuf> {
+    let reference = Path::new(reference.split('#').next().unwrap_or(reference));
+    if reference.is_absolute()
+        || reference.components().any(|component| {
+            matches!(
+                component,
+                Component::ParentDir | Component::RootDir | Component::Prefix(_)
+            )
+        })
+    {
+        return None;
+    }
+    let candidate = if reference.starts_with("assets") {
+        project_root.join(reference)
+    } else {
+        project_root.join("assets").join(reference)
+    };
+    path_stays_within_root(project_root, &candidate).then_some(candidate)
+}
+
+fn normalized_project_reference(reference: &str) -> String {
+    let normalized = reference.replace('\\', "/");
+    let normalized = normalized.strip_prefix("./").unwrap_or(&normalized);
+    if normalized.starts_with("assets/") {
+        normalized.to_string()
+    } else {
+        format!("assets/{normalized}")
+    }
+}
+
+fn path_stays_within_root(project_root: &Path, candidate: &Path) -> bool {
+    let Ok(root) = project_root.canonicalize() else {
+        return false;
+    };
+    let mut existing = candidate;
+    while !existing.exists() {
+        let Some(parent) = existing.parent() else {
+            return false;
+        };
+        existing = parent;
+    }
+    existing
+        .canonicalize()
+        .is_ok_and(|resolved| resolved.starts_with(root))
+}
+
+fn display_project_path(project_root: &Path, path: &Path) -> String {
+    path.strip_prefix(project_root)
+        .unwrap_or(path)
+        .to_string_lossy()
+        .replace('\\', "/")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use shared::{
+        AnimationClipRecord, AnimationImportDiagnostic, AnimationManifestSource,
+        AnimationPlaybackRange, AnimationSkeletonRecord, AnimationSkeletonSignature,
+        AnimationSourceFingerprint, AnimationStateDesc,
+    };
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static NEXT_FIXTURE: AtomicU64 = AtomicU64::new(1);
+    const ANIMATION_ASSET_ID: &str = "model-id";
+    const ANIMATION_MANIFEST_PATH: &str = "assets/animations/generated/model-id.animation.ron";
+
+    fn fixture_root() -> PathBuf {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-project-validation-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(root.join("assets/levels")).unwrap();
+        std::fs::create_dir_all(root.join("assets/.index")).unwrap();
+        std::fs::write(root.join("assets/.index/registry.ron"), "[]").unwrap();
+        write_manifest(&root, 1);
+        root
+    }
+
+    fn write_manifest(root: &Path, version: u32) {
+        std::fs::write(
+            root.join("assets/project.ron"),
+            format!(
+                "(version:{version},template_version:1,default_level:\"assets/levels/main.scn.ron\",asset_roots:[\"assets/levels\"],capabilities:[])"
+            ),
+        )
+        .unwrap();
+    }
+
+    fn composition_scene(scene_id: &str, child_id: &str, child_path: &str) -> String {
+        format!(
+            "(schema_version:2,resources:{{\"shared::components::SceneComposition\":(scene_id:\"{scene_id}\",subscenes:[(id:\"{child_id}\",path:\"{child_path}\",visible:true,locked:true)])}},entities:{{}})"
+        )
+    }
+
+    fn animation_fixture_manifest(
+        source_path: &str,
+        source_format: &str,
+        signature: &str,
+        runtime_supported: bool,
+    ) -> AnimationManifest {
+        let skeleton_signature = AnimationSkeletonSignature::new(signature);
+        AnimationManifest {
+            schema_version: ANIMATION_MANIFEST_SCHEMA_VERSION,
+            asset_id: ANIMATION_ASSET_ID.into(),
+            label: "Hero".into(),
+            source: AnimationManifestSource {
+                path: source_path.into(),
+                format: source_format.into(),
+                fingerprint: AnimationSourceFingerprint {
+                    byte_len: 5,
+                    modified_unix_secs: 1,
+                    content_hash: blake3::hash(b"model").to_hex().to_string(),
+                },
+                dependencies: Vec::new(),
+            },
+            runtime_supported,
+            skeletons: vec![AnimationSkeletonRecord {
+                id: animation_skeleton_sub_asset_id(0, "Hero Rig"),
+                label: "Hero Rig".into(),
+                source_index: 0,
+                signature: skeleton_signature.clone(),
+                joint_paths: vec!["Armature/Hip".into()],
+            }],
+            clips: vec![AnimationClipRecord {
+                id: animation_clip_sub_asset_id(0, "Idle"),
+                label: "Idle".into(),
+                source_index: 0,
+                duration_seconds: 1.0,
+                target_skeleton_signature: Some(skeleton_signature),
+                events: Vec::new(),
+            }],
+            diagnostics: Vec::new(),
+        }
+    }
+
+    fn animation_fixture_controller(manifest: &AnimationManifest) -> AnimationControllerDesc {
+        AnimationControllerDesc {
+            skeleton: Some(EditorAssetRef::new(
+                &manifest.asset_id,
+                &manifest.skeletons[0].id,
+                &manifest.skeletons[0].label,
+            )),
+            states: vec![AnimationStateDesc {
+                id: "idle".into(),
+                label: "Idle".into(),
+                clip: EditorAssetRef::new(
+                    &manifest.asset_id,
+                    &manifest.clips[0].id,
+                    &manifest.clips[0].label,
+                ),
+                looping: true,
+                speed: 1.0,
+                range: AnimationPlaybackRange::default(),
+            }],
+            default_state: "idle".into(),
+            default_crossfade_seconds: 0.2,
+        }
+    }
+
+    fn write_animation_source_and_registry(
+        root: &Path,
+        source_path: &str,
+        animation_manifest_path: Option<&str>,
+    ) {
+        let source = root.join(source_path);
+        std::fs::create_dir_all(source.parent().unwrap()).unwrap();
+        std::fs::write(source, b"model").unwrap();
+        let manifest = animation_manifest_path
+            .map(|path| format!("Some({path:?})"))
+            .unwrap_or_else(|| "None".into());
+        std::fs::write(
+            root.join("assets/.index/registry.ron"),
+            format!(
+                "[(id:(\"{ANIMATION_ASSET_ID}\"),path:\"{source_path}\",kind_tag:\"Model\",import_settings:(static_mesh_manifest_path:None,animation_manifest_path:{manifest}),dependencies:[])]"
+            ),
+        )
+        .unwrap();
+    }
+
+    fn write_animation_manifest(root: &Path, manifest: &AnimationManifest) {
+        let path = root.join(ANIMATION_MANIFEST_PATH);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(
+            path,
+            ron::ser::to_string_pretty(manifest, ron::ser::PrettyConfig::default()).unwrap(),
+        )
+        .unwrap();
+    }
+
+    fn write_animation_scene(root: &Path, controller: &AnimationControllerDesc) {
+        let controller = ron::to_string(controller).unwrap();
+        let mut scene = String::from(
+            "(schema_version:2,resources:{},entities:{1:(components:{\"shared::components::ActorId\":(\"animated-actor\"),\"",
+        );
+        scene.push_str(COMPONENT_ANIMATION_CONTROLLER_DESC);
+        scene.push_str("\":");
+        scene.push_str(&controller);
+        scene.push_str(",})})");
+        std::fs::write(root.join("assets/levels/main.scn.ron"), scene).unwrap();
+    }
+
+    #[test]
+    fn valid_project_fixture_has_no_blocking_findings() {
+        let root = fixture_root();
+        std::fs::create_dir_all(root.join("assets/models")).unwrap();
+        std::fs::write(root.join("assets/models/valid.glb"), b"fixture").unwrap();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("valid-model"),
+                "shared::components::ModelRef":(path:"models/valid.glb",scene_index:0),
+            })})"#,
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+        assert!(report.is_release_ready(), "{:?}", report.findings);
+        assert_eq!(report.dependencies.len(), 2);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn valid_animation_controller_collects_stable_artifact_dependencies() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let manifest = animation_fixture_manifest(source_path, "glb", "rig-signature", true);
+        let controller = animation_fixture_controller(&manifest);
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_manifest(&root, &manifest);
+        write_animation_scene(&root, &controller);
+
+        let report = validate_project(&root);
+
+        assert!(report.is_release_ready(), "{:?}", report.findings);
+        for kind in ["animation_manifest", "animation_skeleton", "animation_clip"] {
+            assert!(
+                report.dependencies.iter().any(|dependency| {
+                    dependency.owner_actor_id.as_deref() == Some("animated-actor")
+                        && dependency.kind == kind
+                }),
+                "missing actor-owned {kind} dependency: {:?}",
+                report.dependencies
+            );
+        }
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn same_size_animation_source_change_invalidates_manifest_content_hash() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let manifest = animation_fixture_manifest(source_path, "glb", "rig-signature", true);
+        let controller = animation_fixture_controller(&manifest);
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_manifest(&root, &manifest);
+        write_animation_scene(&root, &controller);
+        std::fs::write(root.join(source_path), b"modem").unwrap();
+
+        let report = validate_project(&root);
+
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| finding.code == "animation.manifest_stale")
+            .expect("same-size source edits must invalidate the generated animation manifest");
+        assert!(finding.message.contains("byte length is unchanged"));
+        assert!(finding.repair.contains("Reimport"));
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn missing_animation_manifest_is_reported_globally_and_on_the_actor_property() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let manifest = animation_fixture_manifest(source_path, "glb", "rig-signature", true);
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_scene(&root, &animation_fixture_controller(&manifest));
+
+        let report = validate_project(&root);
+
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "animation.manifest_missing" && finding.owner_actor_id.is_none()
+        }));
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| {
+                finding.code == "animation.manifest_missing"
+                    && finding.owner_actor_id.as_deref() == Some("animated-actor")
+            })
+            .expect("missing manifest must identify the owning actor");
+        assert!(finding
+            .reference
+            .as_deref()
+            .is_some_and(|reference| reference.contains("AnimationControllerDesc.skeleton")));
+        assert!(!finding.repair.trim().is_empty());
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn malformed_animation_manifest_is_reported_on_the_actor_property() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let manifest = animation_fixture_manifest(source_path, "glb", "rig-signature", true);
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        let path = root.join(ANIMATION_MANIFEST_PATH);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(path, "not valid RON").unwrap();
+        write_animation_scene(&root, &animation_fixture_controller(&manifest));
+
+        let report = validate_project(&root);
+
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| {
+                finding.code == "animation.manifest_malformed"
+                    && finding.owner_actor_id.as_deref() == Some("animated-actor")
+            })
+            .expect("malformed manifest must identify the owning actor");
+        assert!(finding
+            .reference
+            .as_deref()
+            .is_some_and(|reference| reference.contains("AnimationControllerDesc.skeleton")));
+        assert!(!finding.repair.trim().is_empty());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn missing_animation_clip_is_reported_on_the_exact_state_property() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let manifest = animation_fixture_manifest(source_path, "glb", "rig-signature", true);
+        let mut controller = animation_fixture_controller(&manifest);
+        controller.states[0].clip.sub_asset_id = animation_clip_sub_asset_id(9, "Missing");
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_manifest(&root, &manifest);
+        write_animation_scene(&root, &controller);
+
+        let report = validate_project(&root);
+
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| {
+                finding.code == "animation.clip_missing"
+                    && finding.owner_actor_id.as_deref() == Some("animated-actor")
+            })
+            .expect("missing clip must identify the owning actor state");
+        assert!(finding.reference.as_deref().is_some_and(
+            |reference| reference.contains("AnimationControllerDesc.states[idle].clip")
+        ));
+        assert!(!finding.repair.trim().is_empty());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn invalid_animation_state_contract_reports_each_actor_property() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let manifest = animation_fixture_manifest(source_path, "glb", "rig-signature", true);
+        let mut controller = animation_fixture_controller(&manifest);
+        controller.default_crossfade_seconds = -0.1;
+        controller.states[0].speed = 0.0;
+        controller.states[0].range = AnimationPlaybackRange {
+            start_seconds: 0.75,
+            end_seconds: Some(0.25),
+        };
+        controller.states.push(controller.states[0].clone());
+        controller.default_state = "missing".into();
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_manifest(&root, &manifest);
+        write_animation_scene(&root, &controller);
+
+        let report = validate_project(&root);
+
+        for (code, property) in [
+            (
+                "animation.crossfade_invalid",
+                "AnimationControllerDesc.default_crossfade_seconds",
+            ),
+            (
+                "animation.state_id_invalid",
+                "AnimationControllerDesc.states[idle].id",
+            ),
+            (
+                "animation.speed_invalid",
+                "AnimationControllerDesc.states[idle].speed",
+            ),
+            (
+                "animation.range_invalid",
+                "AnimationControllerDesc.states[idle].range.end_seconds",
+            ),
+            (
+                "animation.default_state_invalid",
+                "AnimationControllerDesc.default_state",
+            ),
+        ] {
+            assert!(
+                report.findings.iter().any(|finding| {
+                    finding.code == code
+                        && finding.owner_actor_id.as_deref() == Some("animated-actor")
+                        && finding
+                            .reference
+                            .as_deref()
+                            .is_some_and(|reference| reference.contains(property))
+                        && !finding.repair.trim().is_empty()
+                }),
+                "missing {code} finding for {property}: {:?}",
+                report.findings
+            );
+        }
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn mismatched_clip_and_skeleton_signatures_block_the_owning_actor() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.glb";
+        let mut manifest = animation_fixture_manifest(source_path, "glb", "rig-a", true);
+        manifest.clips[0].target_skeleton_signature =
+            Some(AnimationSkeletonSignature::new("rig-b"));
+        let controller = animation_fixture_controller(&manifest);
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_manifest(&root, &manifest);
+        write_animation_scene(&root, &controller);
+
+        let report = validate_project(&root);
+
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| {
+                finding.code == "animation.skeleton_mismatch"
+                    && finding.owner_actor_id.as_deref() == Some("animated-actor")
+            })
+            .expect("signature mismatch must identify the owning actor state");
+        assert!(finding.reference.as_deref().is_some_and(
+            |reference| reference.contains("AnimationControllerDesc.states[idle].clip")
+        ));
+        assert!(finding.repair.contains("does not retarget"));
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn animated_fbx_manifest_is_blocking_and_recommends_gltf_export() {
+        let root = fixture_root();
+        let source_path = "assets/models/hero.fbx";
+        let mut manifest = animation_fixture_manifest(source_path, "fbx", "rig-signature", false);
+        manifest.diagnostics.push(AnimationImportDiagnostic {
+            severity: AnimationDiagnosticSeverity::Error,
+            code: "animation.fbx_runtime_unsupported".into(),
+            message: "animated FBX cannot hydrate at runtime".into(),
+            repair: "Export the animated source as glTF 2.0 (.glb or .gltf).".into(),
+        });
+        let controller = animation_fixture_controller(&manifest);
+        write_animation_source_and_registry(&root, source_path, Some(ANIMATION_MANIFEST_PATH));
+        write_animation_manifest(&root, &manifest);
+        write_animation_scene(&root, &controller);
+
+        let report = validate_project(&root);
+
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "animation.fbx_runtime_unsupported"
+                && finding.owner_actor_id.is_none()
+                && finding.repair.contains("glTF 2.0")
+        }));
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "animation.runtime_unsupported"
+                && finding.owner_actor_id.as_deref() == Some("animated-actor")
+                && finding
+                    .reference
+                    .as_deref()
+                    .is_some_and(|reference| reference.contains("AnimationControllerDesc"))
+                && finding.repair.contains("glTF 2.0")
+        }));
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn static_fbx_without_animation_manifest_or_controller_remains_valid() {
+        let root = fixture_root();
+        let source_path = "assets/models/static.fbx";
+        write_animation_source_and_registry(&root, source_path, None);
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("static-model"),
+                "shared::components::ModelRef":(path:"models/static.fbx",scene_index:0),
+            })})"#,
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(report.is_release_ready(), "{:?}", report.findings);
+        assert!(!report
+            .findings
+            .iter()
+            .any(|finding| finding.code.starts_with("animation.")));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn audio_clip_and_bus_are_owner_attributed_runtime_dependencies() {
+        let root = fixture_root();
+        std::fs::create_dir_all(root.join("assets/audio")).unwrap();
+        std::fs::write(root.join("assets/audio/impact.ogg"), b"fixture audio").unwrap();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("audio-source"),
+                "shared::components::AudioSourceDesc":(
+                    clip:Some((asset_id:"audio-id",sub_asset_id:"audio:source",label:"Impact",source_path:Some("assets/audio/impact.ogg"))),
+                    gain_db:0.0,pitch:1.0,looping:false,autoplay:true,spatial_blend:1.0,
+                    attenuation:(min_distance:1.0,max_distance:25.0,rolloff:Inverse,rolloff_factor:1.0),
+                    bus:"sfx",
+                ),
+            })})"#,
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(!report.findings.iter().any(|finding| {
+            finding.owner_actor_id.as_deref() == Some("audio-source")
+                && finding.severity == ValidationSeverity::Error
+        }));
+        assert!(report.dependencies.iter().any(|dependency| {
+            dependency.owner_actor_id.as_deref() == Some("audio-source")
+                && dependency.kind == "audio_clip"
+                && dependency.reference == "assets/audio/impact.ogg"
+        }));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn audio_validation_blocks_missing_clip_unknown_bus_and_listener_ties() {
+        let root = fixture_root();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{
+                1:(components:{
+                    "shared::components::ActorId":("bad-source"),
+                    "shared::components::AudioSourceDesc":(
+                        clip:None,gain_db:0.0,pitch:1.0,looping:false,autoplay:true,spatial_blend:0.0,
+                        attenuation:(min_distance:1.0,max_distance:25.0,rolloff:Inverse,rolloff_factor:1.0),
+                        bus:"missing",
+                    ),
+                }),
+                2:(components:{
+                    "shared::components::ActorId":("listener-a"),
+                    "shared::components::AudioListenerDesc":(enabled:true,priority:10,ear_gap:0.2),
+                }),
+                3:(components:{
+                    "shared::components::ActorId":("listener-b"),
+                    "shared::components::AudioListenerDesc":(enabled:true,priority:10,ear_gap:0.2),
+                }),
+            })"#,
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "audio.clip_missing"
+                && finding.owner_actor_id.as_deref() == Some("bad-source")
+        }));
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "audio.bus_unknown"
+                && finding.owner_actor_id.as_deref() == Some("bad-source")
+        }));
+        assert_eq!(
+            report
+                .findings
+                .iter()
+                .filter(|finding| finding.code == "audio.listener_priority_tie")
+                .count(),
+            2
+        );
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn missing_asset_finding_names_owning_actor() {
+        let root = fixture_root();
+        let scene = r#"(schema_version:2,resources:{},entities:{1:(components:{
+            "shared::components::ActorId":("actor-1"),
+            "shared::components::ModelRef":(path:"models/missing.glb",scene_index:0),
+        })})"#;
+        std::fs::write(root.join("assets/levels/main.scn.ron"), scene).unwrap();
+
+        let report = validate_project(&root);
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| finding.code == "asset.missing")
+            .unwrap();
+        assert_eq!(finding.source_path, "assets/levels/main.scn.ron");
+        assert_eq!(finding.owner_actor_id.as_deref(), Some("actor-1"));
+        assert_eq!(finding.reference.as_deref(), Some("models/missing.glb"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn project_default_level_must_be_in_the_audited_levels_tree() {
+        let root = fixture_root();
+        std::fs::create_dir_all(root.join("assets/custom")).unwrap();
+        std::fs::write(
+            root.join("assets/custom/start.scn.ron"),
+            "(schema_version:2,resources:{},entities:{})",
+        )
+        .unwrap();
+        std::fs::write(
+            root.join("assets/project.ron"),
+            "(version:1,template_version:1,default_level:\"assets/custom/start.scn.ron\",asset_roots:[\"assets/levels\"],capabilities:[])",
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(report
+            .findings
+            .iter()
+            .any(|finding| finding.code == "project.default_level_outside_levels"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn project_default_level_must_be_a_scene_document() {
+        let root = fixture_root();
+        std::fs::write(root.join("assets/levels/splash.png"), b"not a scene").unwrap();
+        std::fs::write(
+            root.join("assets/project.ron"),
+            "(version:1,template_version:1,default_level:\"assets/levels/splash.png\",asset_roots:[\"assets/levels\"],capabilities:[])",
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(report
+            .findings
+            .iter()
+            .any(|finding| finding.code == "project.default_level_outside_levels"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn validation_does_not_follow_symlinked_content_trees() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let outside = std::env::temp_dir().join(format!(
+            "blacksite-validation-outside-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&outside).unwrap();
+        std::fs::write(
+            outside.join("external.scn.ron"),
+            "(schema_version:2,resources:{},entities:{})",
+        )
+        .unwrap();
+        symlink(&outside, root.join("assets/levels/external")).unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "asset.traversal_failed"
+                && finding.source_path.contains("assets/levels/external")
+        }));
+        std::fs::remove_dir_all(root).unwrap();
+        std::fs::remove_dir_all(outside).unwrap();
+    }
+
+    #[test]
+    fn git_lfs_pointer_is_a_blocking_owner_attributed_finding() {
+        let root = fixture_root();
+        std::fs::create_dir_all(root.join("assets/models")).unwrap();
+        std::fs::write(
+            root.join("assets/models/missing-lfs.glb"),
+            b"version https://git-lfs.github.com/spec/v1\noid sha256:0123456789abcdef\nsize 1234\n",
+        )
+        .unwrap();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("lfs-model-owner"),
+                "shared::components::ModelRef":(path:"models/missing-lfs.glb",scene_index:0),
+            })})"#,
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| finding.code == "asset.git_lfs_object_missing")
+            .expect("Git LFS pointer must block project validation");
+        assert_eq!(finding.severity, ValidationSeverity::Error);
+        assert_eq!(finding.source_path, "assets/levels/main.scn.ron");
+        assert_eq!(finding.owner_actor_id.as_deref(), Some("lfs-model-owner"));
+        assert_eq!(finding.reference.as_deref(), Some("models/missing-lfs.glb"));
+        assert!(finding.repair.contains("git lfs pull"));
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn git_lfs_header_detection_requires_the_canonical_first_line() {
+        assert!(has_git_lfs_pointer_header(
+            b"version https://git-lfs.github.com/spec/v1\noid sha256:a\n"
+        ));
+        assert!(has_git_lfs_pointer_header(
+            b"version https://git-lfs.github.com/spec/v1\r\noid sha256:a\r\n"
+        ));
+        assert!(!has_git_lfs_pointer_header(
+            b"prefix version https://git-lfs.github.com/spec/v1\n"
+        ));
+        assert!(!has_git_lfs_pointer_header(
+            b"version https://git-lfs.github.com/spec/v2\n"
+        ));
+    }
+
+    #[test]
+    fn excluded_source_asset_is_a_blocking_runtime_dependency() {
+        let root = fixture_root();
+        std::fs::create_dir_all(root.join("assets/textures")).unwrap();
+        std::fs::write(root.join("assets/textures/source.psd"), b"source").unwrap();
+        let mut report = ProjectValidationReport::default();
+
+        add_reference(
+            &root,
+            &mut report,
+            "assets/levels/main.scn.ron",
+            Some("material-owner"),
+            "texture",
+            "textures/source.psd",
+        );
+
+        let finding = report
+            .findings
+            .iter()
+            .find(|finding| finding.code == "asset.not_packageable")
+            .expect("source-only dependency must block release validation");
+        assert_eq!(finding.owner_actor_id.as_deref(), Some("material-owner"));
+        assert_eq!(finding.reference.as_deref(), Some("textures/source.psd"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn excluded_editor_registry_records_are_not_runtime_dependencies() {
+        let root = fixture_root();
+        std::fs::create_dir_all(root.join("assets/build_profiles")).unwrap();
+        std::fs::write(root.join("assets/build_profiles/development.ron"), b"()").unwrap();
+        std::fs::write(
+            root.join("assets/.index/registry.ron"),
+            "[(id:(\"profile-id\"),path:\"assets/build_profiles/development.ron\",kind_tag:\"Level\",import_settings:(static_mesh_manifest_path:None),dependencies:[])]",
+        )
+        .unwrap();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            "(schema_version:2,resources:{},entities:{})",
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+
+        assert!(!report
+            .findings
+            .iter()
+            .any(|finding| finding.code == "asset.not_packageable"));
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn cyclic_project_fixture_is_blocking() {
+        let root = fixture_root();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            composition_scene("main", "child", "assets/levels/child.scn.ron"),
+        )
+        .unwrap();
+        std::fs::write(
+            root.join("assets/levels/child.scn.ron"),
+            composition_scene("child", "main", "assets/levels/main.scn.ron"),
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "scene.invalid" && finding.message.contains("cyclic subscene")
+        }));
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn incompatible_project_fixture_reports_schema_and_collider() {
+        let root = fixture_root();
+        write_manifest(&root, 99);
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("bad-collider"),
+                "shared::components::ColliderDesc":(enabled:true,is_trigger:false,shape:Sphere(radius:0.0)),
+            })})"#,
+        )
+        .unwrap();
+
+        let report = validate_project(&root);
+        let codes = report
+            .findings
+            .iter()
+            .map(|finding| finding.code.as_str())
+            .collect::<BTreeSet<_>>();
+        assert!(codes.contains("project.incompatible_schema"));
+        assert!(codes.contains("collider.invalid"));
+        assert!(!report.is_release_ready());
+        std::fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn asset_reference_cannot_escape_through_symlink_parent() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let outside = std::env::temp_dir().join(format!(
+            "blacksite-project-validation-outside-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        std::fs::create_dir_all(&outside).unwrap();
+        symlink(&outside, root.join("assets/linked")).unwrap();
+        std::fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("unsafe-model"),
+                "shared::components::ModelRef":(path:"linked/model.glb",scene_index:0),
+            })})"#,
+        )
+        .unwrap();
+        let report = validate_project(&root);
+        assert!(report.findings.iter().any(|finding| {
+            finding.code == "asset.unsafe_path"
+                && finding.owner_actor_id.as_deref() == Some("unsafe-model")
+        }));
+        std::fs::remove_dir_all(root).unwrap();
+        std::fs::remove_dir_all(outside).unwrap();
+    }
+}
diff --git a/crates/settings/src/audio.rs b/crates/settings/src/audio.rs
new file mode 100644
index 0000000..a4f30e8
--- /dev/null
+++ b/crates/settings/src/audio.rs
@@ -0,0 +1,331 @@
+use std::collections::{HashMap, HashSet};
+use std::fmt;
+
+use bevy::prelude::*;
+use serde::{Deserialize, Serialize};
+
+pub const AUDIO_BUS_MASTER_ID: &str = "master";
+pub const AUDIO_BUS_MUSIC_ID: &str = "music";
+pub const AUDIO_BUS_SFX_ID: &str = "sfx";
+pub const AUDIO_GAIN_DB_MIN: f32 = -80.0;
+pub const AUDIO_GAIN_DB_MAX: f32 = 24.0;
+
+/// One stable node in the project audio bus graph.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AudioBusSettings {
+    /// Stable serialized ID. Display names may change without breaking source routing.
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub label: String,
+    #[serde(default)]
+    pub parent: Option<String>,
+    #[serde(default)]
+    pub gain_db: f32,
+    #[serde(default)]
+    pub muted: bool,
+}
+
+impl AudioBusSettings {
+    pub fn new(
+        id: impl Into<String>,
+        label: impl Into<String>,
+        parent: Option<impl Into<String>>,
+    ) -> Self {
+        Self {
+            id: id.into(),
+            label: label.into(),
+            parent: parent.map(Into::into),
+            gain_db: 0.0,
+            muted: false,
+        }
+    }
+}
+
+impl Default for AudioBusSettings {
+    fn default() -> Self {
+        Self::new(AUDIO_BUS_MASTER_ID, "Master", None::<String>)
+    }
+}
+
+/// Versioned project audio routing settings.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AudioSettings {
+    #[serde(default = "default_audio_buses")]
+    pub buses: Vec<AudioBusSettings>,
+}
+
+impl AudioSettings {
+    pub fn bus(&self, id: &str) -> Option<&AudioBusSettings> {
+        self.buses.iter().find(|bus| bus.id == id)
+    }
+
+    pub fn bus_mut(&mut self, id: &str) -> Option<&mut AudioBusSettings> {
+        self.buses.iter_mut().find(|bus| bus.id == id)
+    }
+
+    pub fn validate(&self) -> Result<(), AudioSettingsValidationError> {
+        validate_audio_settings(self)
+    }
+}
+
+impl Default for AudioSettings {
+    fn default() -> Self {
+        Self {
+            buses: default_audio_buses(),
+        }
+    }
+}
+
+fn default_audio_buses() -> Vec<AudioBusSettings> {
+    vec![
+        AudioBusSettings::default(),
+        AudioBusSettings::new(AUDIO_BUS_MUSIC_ID, "Music", Some(AUDIO_BUS_MASTER_ID)),
+        AudioBusSettings::new(AUDIO_BUS_SFX_ID, "SFX", Some(AUDIO_BUS_MASTER_ID)),
+    ]
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AudioSettingsValidationError {
+    EmptyBusId { index: usize },
+    InvalidBusId { bus_id: String },
+    EmptyBusLabel { bus_id: String },
+    DuplicateBusId { bus_id: String },
+    InvalidBusGain { bus_id: String },
+    MissingRequiredBus { bus_id: &'static str },
+    MasterBusHasParent,
+    BusMissingParent { bus_id: String },
+    UnknownParent { bus_id: String, parent_id: String },
+    BusParentCycle { bus_id: String },
+}
+
+impl fmt::Display for AudioSettingsValidationError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::EmptyBusId { index } => write!(formatter, "audio bus {index} has an empty ID"),
+            Self::InvalidBusId { bus_id } => write!(
+                formatter,
+                "audio bus ID `{bus_id}` must use lowercase ASCII letters, digits, '.', '-', or '_'"
+            ),
+            Self::EmptyBusLabel { bus_id } => {
+                write!(formatter, "audio bus `{bus_id}` has an empty label")
+            }
+            Self::DuplicateBusId { bus_id } => {
+                write!(formatter, "audio bus ID `{bus_id}` is duplicated")
+            }
+            Self::InvalidBusGain { bus_id } => write!(
+                formatter,
+                "audio bus `{bus_id}` gain must be finite and between {AUDIO_GAIN_DB_MIN} and {AUDIO_GAIN_DB_MAX} dB"
+            ),
+            Self::MissingRequiredBus { bus_id } => {
+                write!(formatter, "required audio bus `{bus_id}` is missing")
+            }
+            Self::MasterBusHasParent => write!(formatter, "the master audio bus cannot have a parent"),
+            Self::BusMissingParent { bus_id } => {
+                write!(formatter, "audio bus `{bus_id}` does not route to a parent")
+            }
+            Self::UnknownParent { bus_id, parent_id } => write!(
+                formatter,
+                "audio bus `{bus_id}` references unknown parent `{parent_id}`"
+            ),
+            Self::BusParentCycle { bus_id } => {
+                write!(formatter, "audio bus `{bus_id}` participates in a parent cycle")
+            }
+        }
+    }
+}
+
+impl std::error::Error for AudioSettingsValidationError {}
+
+/// Validates stable IDs, required buses, scalar bounds, and the parent graph.
+pub fn validate_audio_settings(
+    settings: &AudioSettings,
+) -> Result<(), AudioSettingsValidationError> {
+    let mut buses = HashMap::with_capacity(settings.buses.len());
+    for (index, bus) in settings.buses.iter().enumerate() {
+        if bus.id.is_empty() {
+            return Err(AudioSettingsValidationError::EmptyBusId { index });
+        }
+        if !valid_bus_id(&bus.id) {
+            return Err(AudioSettingsValidationError::InvalidBusId {
+                bus_id: bus.id.clone(),
+            });
+        }
+        if bus.label.trim().is_empty() {
+            return Err(AudioSettingsValidationError::EmptyBusLabel {
+                bus_id: bus.id.clone(),
+            });
+        }
+        if !bus.gain_db.is_finite()
+            || !(AUDIO_GAIN_DB_MIN..=AUDIO_GAIN_DB_MAX).contains(&bus.gain_db)
+        {
+            return Err(AudioSettingsValidationError::InvalidBusGain {
+                bus_id: bus.id.clone(),
+            });
+        }
+        if buses.insert(bus.id.as_str(), bus).is_some() {
+            return Err(AudioSettingsValidationError::DuplicateBusId {
+                bus_id: bus.id.clone(),
+            });
+        }
+    }
+
+    for required in [AUDIO_BUS_MASTER_ID, AUDIO_BUS_MUSIC_ID, AUDIO_BUS_SFX_ID] {
+        if !buses.contains_key(required) {
+            return Err(AudioSettingsValidationError::MissingRequiredBus { bus_id: required });
+        }
+    }
+
+    if buses[AUDIO_BUS_MASTER_ID].parent.is_some() {
+        return Err(AudioSettingsValidationError::MasterBusHasParent);
+    }
+
+    for bus in settings
+        .buses
+        .iter()
+        .filter(|bus| bus.id != AUDIO_BUS_MASTER_ID)
+    {
+        let Some(parent_id) = bus.parent.as_deref().filter(|parent| !parent.is_empty()) else {
+            return Err(AudioSettingsValidationError::BusMissingParent {
+                bus_id: bus.id.clone(),
+            });
+        };
+        if !buses.contains_key(parent_id) {
+            return Err(AudioSettingsValidationError::UnknownParent {
+                bus_id: bus.id.clone(),
+                parent_id: parent_id.to_string(),
+            });
+        }
+    }
+
+    for bus in settings
+        .buses
+        .iter()
+        .filter(|bus| bus.id != AUDIO_BUS_MASTER_ID)
+    {
+        let mut current = bus.id.as_str();
+        let mut visited = HashSet::new();
+        while current != AUDIO_BUS_MASTER_ID {
+            if !visited.insert(current) {
+                return Err(AudioSettingsValidationError::BusParentCycle {
+                    bus_id: bus.id.clone(),
+                });
+            }
+            current = buses[current]
+                .parent
+                .as_deref()
+                .expect("non-master parents were validated above");
+        }
+    }
+
+    Ok(())
+}
+
+fn valid_bus_id(id: &str) -> bool {
+    id.bytes().all(|byte| {
+        byte.is_ascii_lowercase() || byte.is_ascii_digit() || matches!(byte, b'.' | b'-' | b'_')
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_bus_graph_uses_stable_required_ids() {
+        let settings = AudioSettings::default();
+
+        assert_eq!(
+            settings
+                .buses
+                .iter()
+                .map(|bus| bus.id.as_str())
+                .collect::<Vec<_>>(),
+            [AUDIO_BUS_MASTER_ID, AUDIO_BUS_MUSIC_ID, AUDIO_BUS_SFX_ID]
+        );
+        assert_eq!(
+            settings.bus(AUDIO_BUS_MUSIC_ID).unwrap().parent.as_deref(),
+            Some(AUDIO_BUS_MASTER_ID)
+        );
+        assert_eq!(
+            settings.bus(AUDIO_BUS_SFX_ID).unwrap().parent.as_deref(),
+            Some(AUDIO_BUS_MASTER_ID)
+        );
+        assert!(settings.validate().is_ok());
+    }
+
+    #[test]
+    fn rejects_duplicate_and_unknown_bus_references() {
+        let mut settings = AudioSettings::default();
+        settings.buses.push(AudioBusSettings::new(
+            AUDIO_BUS_SFX_ID,
+            "Duplicate",
+            Some(AUDIO_BUS_MASTER_ID),
+        ));
+        assert_eq!(
+            settings.validate(),
+            Err(AudioSettingsValidationError::DuplicateBusId {
+                bus_id: AUDIO_BUS_SFX_ID.to_string()
+            })
+        );
+
+        let mut settings = AudioSettings::default();
+        settings.bus_mut(AUDIO_BUS_SFX_ID).unwrap().parent = Some("missing".into());
+        assert_eq!(
+            settings.validate(),
+            Err(AudioSettingsValidationError::UnknownParent {
+                bus_id: AUDIO_BUS_SFX_ID.to_string(),
+                parent_id: "missing".to_string(),
+            })
+        );
+    }
+
+    #[test]
+    fn rejects_parent_cycles_and_invalid_gain() {
+        let mut settings = AudioSettings::default();
+        settings.bus_mut(AUDIO_BUS_MUSIC_ID).unwrap().parent = Some(AUDIO_BUS_SFX_ID.into());
+        settings.bus_mut(AUDIO_BUS_SFX_ID).unwrap().parent = Some(AUDIO_BUS_MUSIC_ID.into());
+        assert_eq!(
+            settings.validate(),
+            Err(AudioSettingsValidationError::BusParentCycle {
+                bus_id: AUDIO_BUS_MUSIC_ID.to_string()
+            })
+        );
+
+        let mut settings = AudioSettings::default();
+        settings.bus_mut(AUDIO_BUS_SFX_ID).unwrap().gain_db = f32::NAN;
+        assert_eq!(
+            settings.validate(),
+            Err(AudioSettingsValidationError::InvalidBusGain {
+                bus_id: AUDIO_BUS_SFX_ID.to_string()
+            })
+        );
+    }
+
+    #[test]
+    fn rejects_missing_required_and_unstable_bus_ids() {
+        let mut settings = AudioSettings::default();
+        settings.buses.retain(|bus| bus.id != AUDIO_BUS_MUSIC_ID);
+        assert_eq!(
+            settings.validate(),
+            Err(AudioSettingsValidationError::MissingRequiredBus {
+                bus_id: AUDIO_BUS_MUSIC_ID
+            })
+        );
+
+        let mut settings = AudioSettings::default();
+        settings.buses.push(AudioBusSettings::new(
+            "Dialogue Bus",
+            "Dialogue",
+            Some(AUDIO_BUS_MASTER_ID),
+        ));
+        assert_eq!(
+            settings.validate(),
+            Err(AudioSettingsValidationError::InvalidBusId {
+                bus_id: "Dialogue Bus".to_string()
+            })
+        );
+    }
+}
diff --git a/crates/settings/src/lib.rs b/crates/settings/src/lib.rs
index 1505ad5..b97293a 100644
--- a/crates/settings/src/lib.rs
+++ b/crates/settings/src/lib.rs
@@ -1,8 +1,10 @@
 //! Serializable project settings loaded from `assets/project.ron`.
 
+mod audio;
 mod plugin;
 mod rendering;
 
+pub use audio::*;
 pub use plugin::{
     save_project_settings, sync_sim_tuning, ProjectSettingsChanged, ProjectSettingsIo,
     ProjectSettingsPlugin, SimTuning,
@@ -19,6 +21,15 @@ use serde::{Deserialize, Serialize};
 
 pub const DEFAULT_PROJECT_PATH: &str = "assets/project.ron";
 pub const SETTINGS_VERSION: u32 = 1;
+pub const PROJECT_TEMPLATE_VERSION: u32 = 1;
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, Reflect, PartialEq, Eq)]
+#[reflect(Clone)]
+pub enum ProjectKind {
+    #[default]
+    Game,
+    Sandbox,
+}
 
 /// Marker for cameras that receive the shared project rendering stack.
 #[derive(Component, Debug, Clone, Copy, Default)]
@@ -29,10 +40,20 @@ pub struct ProjectRenderCamera;
 #[reflect(Resource, Clone)]
 pub struct ProjectSettings {
     pub version: u32,
+    #[serde(default)]
+    pub project_id: String,
     pub name: String,
+    #[serde(default)]
+    pub project_kind: ProjectKind,
+    #[serde(default = "default_project_template_version")]
+    pub template_version: u32,
+    #[serde(default)]
+    pub capabilities: Vec<String>,
     pub default_level: String,
     pub asset_roots: Vec<String>,
     pub rendering: RenderingSettings,
+    #[serde(default)]
+    pub audio: AudioSettings,
     pub physics: PhysicsSettings,
     pub input: InputSettings,
 }
@@ -41,21 +62,36 @@ impl Default for ProjectSettings {
     fn default() -> Self {
         Self {
             version: SETTINGS_VERSION,
+            project_id: "blacksite-default".into(),
             name: "Bevy FPS Foundation".into(),
+            project_kind: ProjectKind::Game,
+            template_version: PROJECT_TEMPLATE_VERSION,
+            capabilities: vec![
+                "editor".into(),
+                "gameplay".into(),
+                "rendering".into(),
+                "audio".into(),
+            ],
             default_level: "assets/levels/editor_scene.scn.ron".into(),
             asset_roots: vec![
                 "assets/models".into(),
                 "assets/textures".into(),
                 "assets/materials".into(),
                 "assets/levels".into(),
+                "assets/audio".into(),
             ],
             rendering: RenderingSettings::default(),
+            audio: AudioSettings::default(),
             physics: PhysicsSettings::default(),
             input: InputSettings::default(),
         }
     }
 }
 
+const fn default_project_template_version() -> u32 {
+    PROJECT_TEMPLATE_VERSION
+}
+
 /// Camera post-processing and world lighting defaults.
 #[derive(Debug, Clone, Serialize, Deserialize, Reflect)]
 #[reflect(Clone)]
@@ -221,10 +257,68 @@ mod tests {
         let text = save_project_settings_to_string(&settings).expect("serialize");
         let parsed: ProjectSettings = ron::from_str(&text).expect("deserialize");
         assert_eq!(parsed.name, settings.name);
+        assert_eq!(parsed.project_id, settings.project_id);
+        assert_eq!(parsed.project_kind, settings.project_kind);
+        assert_eq!(parsed.template_version, settings.template_version);
+        assert_eq!(parsed.capabilities, settings.capabilities);
+        assert_eq!(parsed.audio, settings.audio);
         assert_eq!(parsed.physics.walk_speed, settings.physics.walk_speed);
         assert_eq!(parsed.rendering.gi_mode, settings.rendering.gi_mode);
     }
 
+    #[test]
+    fn legacy_manifest_defaults_project_identity_fields() {
+        let legacy = r#"(
+            version: 1,
+            name: "Legacy",
+            default_level: "assets/levels/main.scn.ron",
+            asset_roots: [],
+            rendering: (
+                gi_mode: Auto, hdr: true, exposure_mode: Manual, exposure_ev100: 13.0,
+                auto_exposure_speed_brighten: 3.0, auto_exposure_speed_darken: 1.0,
+                tonemapping_aces: true, bloom: true, taa: true, ssao: true,
+                atmosphere: true, fog_color: (0.0, 0.0, 0.0), fog_density: 0.0,
+                ambient_color: (0.0, 0.0, 0.0), ambient_brightness: 0.0,
+                sun_illuminance: 100000.0, shadow_cascades: 4,
+                shadow_first_cascade: 6.0, shadow_max_distance: 220.0,
+            ),
+            physics: (
+                player_radius: 0.4, player_length: 1.0, eye_offset_stand: 0.6,
+                eye_offset_crouch: 0.1, gravity: 22.0, walk_speed: 6.0,
+                run_speed: 9.5, crouch_speed: 3.0, jump_speed: 7.5,
+                ground_accel: 70.0, air_accel: 16.0, ground_check_dist: 0.2,
+                skin: 0.02, max_slide_iter: 4, ground_normal_y: 0.5,
+                coyote_time: 0.12, jump_buffer: 0.12,
+            ),
+            input: (
+                yaw_sensitivity: 0.003, pitch_sensitivity: 0.0022,
+                editor_fly_speed: 14.0, editor_look_sensitivity: 0.003,
+                editor_pan_speed: 0.015,
+            ),
+        )"#;
+
+        let parsed: ProjectSettings = ron::from_str(legacy).unwrap();
+
+        assert!(parsed.project_id.is_empty());
+        assert_eq!(parsed.project_kind, ProjectKind::Game);
+        assert_eq!(parsed.template_version, PROJECT_TEMPLATE_VERSION);
+        assert!(parsed.capabilities.is_empty());
+        assert_eq!(parsed.audio, AudioSettings::default());
+        assert!(parsed.audio.validate().is_ok());
+    }
+
+    #[test]
+    fn project_defaults_include_audio_capability_and_asset_root() {
+        let settings = ProjectSettings::default();
+
+        assert!(settings.capabilities.iter().any(|item| item == "audio"));
+        assert!(settings
+            .asset_roots
+            .iter()
+            .any(|item| item == "assets/audio"));
+        assert!(settings.audio.validate().is_ok());
+    }
+
     #[test]
     fn gi_mode_defaults_auto() {
         assert_eq!(RenderingSettings::default().gi_mode, GiMode::Auto);
diff --git a/crates/settings/src/plugin.rs b/crates/settings/src/plugin.rs
index 88abd60..7fc5db5 100644
--- a/crates/settings/src/plugin.rs
+++ b/crates/settings/src/plugin.rs
@@ -77,6 +77,9 @@ impl Plugin for ProjectSettingsPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<ProjectSettingsIo>()
             .register_type::<ProjectSettings>()
+            .register_type::<crate::ProjectKind>()
+            .register_type::<crate::AudioSettings>()
+            .register_type::<crate::AudioBusSettings>()
             .register_type::<crate::GiMode>()
             .register_type::<crate::ExposureMode>()
             .register_type::<crate::ActiveCameraRenderProfile>()
diff --git a/crates/shared/src/actor.rs b/crates/shared/src/actor.rs
index a93b206..3bd8b2e 100644
--- a/crates/shared/src/actor.rs
+++ b/crates/shared/src/actor.rs
@@ -1,12 +1,17 @@
 //! Actor kind inference (migration only) and save-time validation.
 
+use std::collections::HashSet;
+use std::path::Path;
+
 use bevy::ecs::world::EntityRef;
 use bevy::prelude::*;
 
 use crate::{
-    brush_math::validate_brush, ActorKind, BrushDesc, LevelObject, LightDesc, ModelRef,
-    ObjectiveMarker, PlayerSpawn, PostProcessVolumeDesc, PrefabInstance, PrefabRef, Primitive,
-    StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
+    animation_clip_source_index, animation_skeleton_source_index, brush_math::validate_brush,
+    ActorKind, AnimationControllerDesc, AudioListenerDesc, AudioSourceDesc, BrushDesc, LevelObject,
+    LightDesc, ModelRef, ObjectiveMarker, PlayerSpawn, PostProcessVolumeDesc, PrefabInstance,
+    PrefabRef, Primitive, StaticMeshRenderer, TeamSpawn, TriggerVolume, WeaponSpawn,
+    AUDIO_CLIP_SUB_ASSET_ID,
 };
 
 /// One-shot deterministic kind from authoring components (scene migration only).
@@ -45,6 +50,12 @@ pub fn infer_actor_kind(entity: EntityRef<'_>) -> Option<ActorKind> {
     if entity.get::<PrefabRef>().is_some() || entity.get::<PrefabInstance>().is_some() {
         return Some(ActorKind::PrefabAnchor);
     }
+    if entity.get::<AudioSourceDesc>().is_some() {
+        return Some(ActorKind::AudioSource);
+    }
+    if entity.get::<AudioListenerDesc>().is_some() {
+        return Some(ActorKind::AudioListener);
+    }
     Some(ActorKind::Empty)
 }
 
@@ -72,6 +83,27 @@ pub enum ActorValidationError {
     PostProcessVolumeInvalidBlendDistance,
     PostProcessVolumeInvalidOverrideScalar,
     PostProcessVolumeMissingDesc,
+    AudioSourceMissingDesc,
+    AudioSourceMissingClip,
+    AudioSourceInvalidClipReference,
+    AudioSourceInvalidGain,
+    AudioSourceInvalidPitch,
+    AudioSourceInvalidSpatialBlend,
+    AudioSourceInvalidAttenuation,
+    AudioSourceMissingBus,
+    AudioListenerMissingDesc,
+    AudioListenerInvalidEarGap,
+    AnimationControllerMissingModelRef,
+    AnimationControllerMissingSkeleton,
+    AnimationControllerInvalidSkeletonReference,
+    AnimationControllerEmptyStateId,
+    AnimationControllerDuplicateStateId,
+    AnimationControllerInvalidClipReference,
+    AnimationControllerInvalidStateSpeed,
+    AnimationControllerInvalidStateRange,
+    AnimationControllerInvalidCrossfade,
+    AnimationControllerMissingDefaultState,
+    AnimationControllerUnknownDefaultState,
 }
 
 fn is_finite_positive(v: f32) -> bool {
@@ -96,6 +128,19 @@ pub fn validate_actor(entity: EntityRef<'_>) -> Result<(), ActorValidationError>
         return Err(ActorValidationError::MissingTransform);
     }
 
+    if let Some(source) = entity.get::<AudioSourceDesc>() {
+        validate_audio_source(source)?;
+    }
+    if let Some(listener) = entity.get::<AudioListenerDesc>() {
+        validate_audio_listener(listener)?;
+    }
+    if let Some(controller) = entity.get::<AnimationControllerDesc>() {
+        if entity.get::<ModelRef>().is_none() {
+            return Err(ActorValidationError::AnimationControllerMissingModelRef);
+        }
+        validate_animation_controller(controller)?;
+    }
+
     match kind {
         ActorKind::Brush => {
             let Some(brush) = entity.get::<BrushDesc>() else {
@@ -190,6 +235,16 @@ pub fn validate_actor(entity: EntityRef<'_>) -> Result<(), ActorValidationError>
                 }
             }
         }
+        ActorKind::AudioSource => {
+            if entity.get::<AudioSourceDesc>().is_none() {
+                return Err(ActorValidationError::AudioSourceMissingDesc);
+            }
+        }
+        ActorKind::AudioListener => {
+            if entity.get::<AudioListenerDesc>().is_none() {
+                return Err(ActorValidationError::AudioListenerMissingDesc);
+            }
+        }
         ActorKind::Empty
         | ActorKind::PrefabAnchor
         | ActorKind::PlayerSpawn
@@ -202,10 +257,111 @@ pub fn validate_actor(entity: EntityRef<'_>) -> Result<(), ActorValidationError>
     Ok(())
 }
 
+fn validate_audio_source(source: &AudioSourceDesc) -> Result<(), ActorValidationError> {
+    let Some(clip) = source.clip.as_ref() else {
+        return Err(ActorValidationError::AudioSourceMissingClip);
+    };
+    if !clip.is_resolved() || clip.sub_asset_id != AUDIO_CLIP_SUB_ASSET_ID {
+        return Err(ActorValidationError::AudioSourceInvalidClipReference);
+    }
+    if !source.gain_db.is_finite()
+        || !(settings::AUDIO_GAIN_DB_MIN..=settings::AUDIO_GAIN_DB_MAX).contains(&source.gain_db)
+    {
+        return Err(ActorValidationError::AudioSourceInvalidGain);
+    }
+    if !is_finite_positive(source.pitch) {
+        return Err(ActorValidationError::AudioSourceInvalidPitch);
+    }
+    if !source.spatial_blend.is_finite() || !(0.0..=1.0).contains(&source.spatial_blend) {
+        return Err(ActorValidationError::AudioSourceInvalidSpatialBlend);
+    }
+    let attenuation = source.attenuation;
+    if !is_finite_non_negative(attenuation.min_distance)
+        || !attenuation.max_distance.is_finite()
+        || attenuation.max_distance <= attenuation.min_distance
+        || !is_finite_non_negative(attenuation.rolloff_factor)
+    {
+        return Err(ActorValidationError::AudioSourceInvalidAttenuation);
+    }
+    if source.bus.trim().is_empty() {
+        return Err(ActorValidationError::AudioSourceMissingBus);
+    }
+    Ok(())
+}
+
+fn validate_audio_listener(listener: &AudioListenerDesc) -> Result<(), ActorValidationError> {
+    if !is_finite_positive(listener.ear_gap) {
+        return Err(ActorValidationError::AudioListenerInvalidEarGap);
+    }
+    Ok(())
+}
+
+fn validate_animation_controller(
+    controller: &AnimationControllerDesc,
+) -> Result<(), ActorValidationError> {
+    let Some(skeleton) = controller.skeleton.as_ref() else {
+        return Err(ActorValidationError::AnimationControllerMissingSkeleton);
+    };
+    if !skeleton.is_resolved() || animation_skeleton_source_index(&skeleton.sub_asset_id).is_none()
+    {
+        return Err(ActorValidationError::AnimationControllerInvalidSkeletonReference);
+    }
+
+    let mut state_ids = HashSet::with_capacity(controller.states.len());
+    for state in &controller.states {
+        if state.id.trim().is_empty() {
+            return Err(ActorValidationError::AnimationControllerEmptyStateId);
+        }
+        if !state_ids.insert(state.id.as_str()) {
+            return Err(ActorValidationError::AnimationControllerDuplicateStateId);
+        }
+        let clip_source_is_gltf = state
+            .clip
+            .source_path
+            .as_deref()
+            .and_then(|path| Path::new(path).extension())
+            .and_then(|extension| extension.to_str())
+            .is_some_and(|extension| {
+                extension.eq_ignore_ascii_case("gltf") || extension.eq_ignore_ascii_case("glb")
+            });
+        if !state.clip.is_resolved()
+            || animation_clip_source_index(&state.clip.sub_asset_id).is_none()
+            || !clip_source_is_gltf
+        {
+            return Err(ActorValidationError::AnimationControllerInvalidClipReference);
+        }
+        if !state.speed.is_finite() || state.speed <= 0.0 {
+            return Err(ActorValidationError::AnimationControllerInvalidStateSpeed);
+        }
+        if !is_finite_non_negative(state.range.start_seconds)
+            || state
+                .range
+                .end_seconds
+                .is_some_and(|end| !end.is_finite() || end < 0.0 || end < state.range.start_seconds)
+        {
+            return Err(ActorValidationError::AnimationControllerInvalidStateRange);
+        }
+    }
+
+    if !is_finite_non_negative(controller.default_crossfade_seconds) {
+        return Err(ActorValidationError::AnimationControllerInvalidCrossfade);
+    }
+    if controller.default_state.trim().is_empty() {
+        return Err(ActorValidationError::AnimationControllerMissingDefaultState);
+    }
+    if !state_ids.contains(controller.default_state.as_str()) {
+        return Err(ActorValidationError::AnimationControllerUnknownDefaultState);
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::PostProcessVolumeDesc;
+    use crate::{
+        animation_clip_sub_asset_id, animation_skeleton_sub_asset_id, AnimationPlaybackRange,
+        AnimationStateDesc, EditorAssetRef, PostProcessVolumeDesc,
+    };
 
     fn level_entity(world: &mut World, bundle: impl Bundle) -> Entity {
         world
@@ -213,6 +369,40 @@ mod tests {
             .id()
     }
 
+    fn audio_source() -> AudioSourceDesc {
+        AudioSourceDesc {
+            clip: Some(
+                crate::EditorAssetRef::new("audio-id", AUDIO_CLIP_SUB_ASSET_ID, "Tone")
+                    .with_source_path("assets/audio/tone.ogg"),
+            ),
+            ..Default::default()
+        }
+    }
+
+    fn animation_controller() -> AnimationControllerDesc {
+        AnimationControllerDesc {
+            skeleton: Some(
+                EditorAssetRef::new("model-id", animation_skeleton_sub_asset_id(0, "Rig"), "Rig")
+                    .with_source_path("assets/models/animated.glb"),
+            ),
+            states: vec![AnimationStateDesc {
+                id: "idle".into(),
+                label: "Idle".into(),
+                clip: EditorAssetRef::new(
+                    "model-id",
+                    animation_clip_sub_asset_id(0, "Idle"),
+                    "Idle",
+                )
+                .with_source_path("assets/models/animated.glb"),
+                looping: true,
+                speed: 1.0,
+                range: AnimationPlaybackRange::default(),
+            }],
+            default_state: "idle".into(),
+            default_crossfade_seconds: 0.2,
+        }
+    }
+
     #[test]
     fn validate_static_mesh_ok() {
         let mut world = World::new();
@@ -318,4 +508,211 @@ mod tests {
             Err(ActorValidationError::PostProcessVolumeInvalidHalfExtents)
         );
     }
+
+    #[test]
+    fn infers_and_validates_audio_source_and_listener_actors() {
+        let mut world = World::new();
+        let source = level_entity(&mut world, audio_source());
+        let listener = level_entity(&mut world, AudioListenerDesc::default());
+
+        assert_eq!(
+            infer_actor_kind(world.entity(source)),
+            Some(ActorKind::AudioSource)
+        );
+        assert_eq!(
+            infer_actor_kind(world.entity(listener)),
+            Some(ActorKind::AudioListener)
+        );
+        world.entity_mut(source).insert(ActorKind::AudioSource);
+        world.entity_mut(listener).insert(ActorKind::AudioListener);
+        assert!(validate_actor(world.entity(source)).is_ok());
+        assert!(validate_actor(world.entity(listener)).is_ok());
+    }
+
+    #[test]
+    fn audio_source_requires_a_stable_clip_reference() {
+        let mut world = World::new();
+        let entity = level_entity(
+            &mut world,
+            (ActorKind::AudioSource, AudioSourceDesc::default()),
+        );
+
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AudioSourceMissingClip)
+        );
+
+        world.entity_mut(entity).insert(AudioSourceDesc {
+            clip: Some(crate::EditorAssetRef::new("audio-id", "mesh:0", "Wrong")),
+            ..Default::default()
+        });
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AudioSourceInvalidClipReference)
+        );
+    }
+
+    #[test]
+    fn audio_scalar_and_attenuation_ranges_are_validated() {
+        let mut world = World::new();
+        let entity = level_entity(
+            &mut world,
+            (
+                ActorKind::AudioSource,
+                AudioSourceDesc {
+                    spatial_blend: 1.5,
+                    ..audio_source()
+                },
+            ),
+        );
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AudioSourceInvalidSpatialBlend)
+        );
+
+        let listener = level_entity(
+            &mut world,
+            (
+                ActorKind::AudioListener,
+                AudioListenerDesc {
+                    ear_gap: 0.0,
+                    ..Default::default()
+                },
+            ),
+        );
+        assert_eq!(
+            validate_actor(world.entity(listener)),
+            Err(ActorValidationError::AudioListenerInvalidEarGap)
+        );
+    }
+
+    #[test]
+    fn animation_controller_requires_model_and_resolved_skeleton() {
+        let mut world = World::new();
+        let entity = level_entity(
+            &mut world,
+            (ActorKind::ImportedModel, animation_controller()),
+        );
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerMissingModelRef)
+        );
+
+        world
+            .entity_mut(entity)
+            .insert(ModelRef::new("assets/models/animated.glb"));
+        let mut controller = animation_controller();
+        controller.skeleton = None;
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerMissingSkeleton)
+        );
+
+        let mut controller = animation_controller();
+        controller.skeleton = Some(EditorAssetRef::new("model-id", "mesh:0", "Wrong"));
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerInvalidSkeletonReference)
+        );
+
+        world.entity_mut(entity).insert(animation_controller());
+        assert!(validate_actor(world.entity(entity)).is_ok());
+    }
+
+    #[test]
+    fn animation_controller_validates_state_identity_and_clip_reference() {
+        let mut world = World::new();
+        let entity = level_entity(
+            &mut world,
+            (
+                ActorKind::ImportedModel,
+                ModelRef::new("assets/models/animated.glb"),
+                animation_controller(),
+            ),
+        );
+
+        let mut controller = animation_controller();
+        controller.states[0].id = " ".into();
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerEmptyStateId)
+        );
+
+        let mut controller = animation_controller();
+        controller.states.push(controller.states[0].clone());
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerDuplicateStateId)
+        );
+
+        let mut controller = animation_controller();
+        controller.states[0].clip =
+            EditorAssetRef::new("model-id", animation_clip_sub_asset_id(0, "Idle"), "Idle")
+                .with_source_path("assets/models/animated.fbx");
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerInvalidClipReference)
+        );
+    }
+
+    #[test]
+    fn animation_controller_validates_playback_ranges_and_default_state() {
+        let mut world = World::new();
+        let entity = level_entity(
+            &mut world,
+            (
+                ActorKind::ImportedModel,
+                ModelRef::new("assets/models/animated.glb"),
+                animation_controller(),
+            ),
+        );
+
+        let mut controller = animation_controller();
+        controller.states[0].speed = 0.0;
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerInvalidStateSpeed)
+        );
+
+        let mut controller = animation_controller();
+        controller.states[0].range = AnimationPlaybackRange {
+            start_seconds: 1.0,
+            end_seconds: Some(0.5),
+        };
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerInvalidStateRange)
+        );
+
+        let mut controller = animation_controller();
+        controller.default_crossfade_seconds = f32::NAN;
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerInvalidCrossfade)
+        );
+
+        let mut controller = animation_controller();
+        controller.default_state.clear();
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerMissingDefaultState)
+        );
+
+        let mut controller = animation_controller();
+        controller.default_state = "missing".into();
+        world.entity_mut(entity).insert(controller);
+        assert_eq!(
+            validate_actor(world.entity(entity)),
+            Err(ActorValidationError::AnimationControllerUnknownDefaultState)
+        );
+    }
 }
diff --git a/crates/shared/src/animation.rs b/crates/shared/src/animation.rs
new file mode 100644
index 0000000..d8d4a6b
--- /dev/null
+++ b/crates/shared/src/animation.rs
@@ -0,0 +1,318 @@
+//! Persistent animation authoring data and generated import-manifest contract.
+
+use bevy::prelude::*;
+use serde::{Deserialize, Serialize};
+
+use crate::EditorAssetRef;
+
+pub const ANIMATION_MANIFEST_SCHEMA_VERSION: u32 = 2;
+pub const ANIMATION_ARTIFACT_DIR: &str = "assets/animations/generated";
+pub const ANIMATION_CLIP_SUB_ASSET_PREFIX: &str = "animation:clip:";
+pub const ANIMATION_SKELETON_SUB_ASSET_PREFIX: &str = "animation:skeleton:";
+pub const COMPONENT_ANIMATION_CONTROLLER_DESC: &str = "shared::animation::AnimationControllerDesc";
+
+const DEFAULT_CROSSFADE_SECONDS: f32 = 0.2;
+const DEFAULT_PLAYBACK_SPEED: f32 = 1.0;
+
+pub fn animation_clip_sub_asset_id(source_index: usize, label: &str) -> String {
+    animation_sub_asset_id(ANIMATION_CLIP_SUB_ASSET_PREFIX, source_index, label)
+}
+
+pub fn animation_skeleton_sub_asset_id(source_index: usize, label: &str) -> String {
+    animation_sub_asset_id(ANIMATION_SKELETON_SUB_ASSET_PREFIX, source_index, label)
+}
+
+pub fn animation_clip_source_index(sub_asset_id: &str) -> Option<usize> {
+    animation_source_index(sub_asset_id, ANIMATION_CLIP_SUB_ASSET_PREFIX)
+}
+
+pub fn animation_skeleton_source_index(sub_asset_id: &str) -> Option<usize> {
+    animation_source_index(sub_asset_id, ANIMATION_SKELETON_SUB_ASSET_PREFIX)
+}
+
+fn animation_sub_asset_id(prefix: &str, source_index: usize, label: &str) -> String {
+    let slug = stable_slug(label);
+    if slug.is_empty() {
+        format!("{prefix}{source_index}:unnamed")
+    } else {
+        format!("{prefix}{source_index}:{slug}")
+    }
+}
+
+fn animation_source_index(sub_asset_id: &str, prefix: &str) -> Option<usize> {
+    sub_asset_id
+        .strip_prefix(prefix)?
+        .split_once(':')?
+        .0
+        .parse()
+        .ok()
+}
+
+fn stable_slug(label: &str) -> String {
+    let mut slug = String::new();
+    for character in label.chars() {
+        if character.is_ascii_alphanumeric() {
+            slug.push(character.to_ascii_lowercase());
+        } else if !slug.ends_with('_') {
+            slug.push('_');
+        }
+    }
+    slug.trim_matches('_').to_string()
+}
+
+/// Exact identity of an imported skeleton's ordered joint paths and bind-pose structure.
+#[derive(Reflect, Default, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AnimationSkeletonSignature(pub String);
+
+impl AnimationSkeletonSignature {
+    pub fn new(signature: impl Into<String>) -> Self {
+        Self(signature.into())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.trim().is_empty()
+    }
+}
+
+/// Authored playback window inside an imported clip.
+#[derive(Reflect, Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AnimationPlaybackRange {
+    #[serde(default)]
+    pub start_seconds: f32,
+    /// `None` plays to the imported clip duration.
+    #[serde(default)]
+    pub end_seconds: Option<f32>,
+}
+
+impl Default for AnimationPlaybackRange {
+    fn default() -> Self {
+        Self {
+            start_seconds: 0.0,
+            end_seconds: None,
+        }
+    }
+}
+
+/// One normalized event marker imported with an animation clip.
+#[derive(Reflect, Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AnimationEventDesc {
+    pub id: String,
+    pub time_seconds: f32,
+    #[serde(default)]
+    pub payload: Option<String>,
+}
+
+/// One stable, gameplay-addressable state in the v1 single-layer controller.
+#[derive(Reflect, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AnimationStateDesc {
+    /// Stable runtime key. Display labels are not gameplay identifiers.
+    pub id: String,
+    #[serde(default)]
+    pub label: String,
+    pub clip: EditorAssetRef,
+    #[serde(default = "default_true")]
+    pub looping: bool,
+    #[serde(default = "default_playback_speed")]
+    pub speed: f32,
+    #[serde(default)]
+    pub range: AnimationPlaybackRange,
+}
+
+impl Default for AnimationStateDesc {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            label: String::new(),
+            clip: EditorAssetRef::default(),
+            looping: true,
+            speed: DEFAULT_PLAYBACK_SPEED,
+            range: AnimationPlaybackRange::default(),
+        }
+    }
+}
+
+/// Scene-authored single-layer animation controller.
+///
+/// Bevy graph, player, transition, and instantiated-world state are derived at runtime.
+#[derive(Component, Reflect, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[reflect(Component, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AnimationControllerDesc {
+    #[serde(default)]
+    pub skeleton: Option<EditorAssetRef>,
+    #[serde(default)]
+    pub states: Vec<AnimationStateDesc>,
+    /// Stable state ID selected when the hydrated model becomes ready.
+    #[serde(default)]
+    pub default_state: String,
+    #[serde(default = "default_crossfade_seconds")]
+    pub default_crossfade_seconds: f32,
+}
+
+impl Default for AnimationControllerDesc {
+    fn default() -> Self {
+        Self {
+            skeleton: None,
+            states: Vec::new(),
+            default_state: String::new(),
+            default_crossfade_seconds: DEFAULT_CROSSFADE_SECONDS,
+        }
+    }
+}
+
+impl AnimationControllerDesc {
+    pub fn state(&self, id: &str) -> Option<&AnimationStateDesc> {
+        self.states.iter().find(|state| state.id == id)
+    }
+
+    pub fn state_mut(&mut self, id: &str) -> Option<&mut AnimationStateDesc> {
+        self.states.iter_mut().find(|state| state.id == id)
+    }
+}
+
+fn default_true() -> bool {
+    true
+}
+
+fn default_playback_speed() -> f32 {
+    DEFAULT_PLAYBACK_SPEED
+}
+
+fn default_crossfade_seconds() -> f32 {
+    DEFAULT_CROSSFADE_SECONDS
+}
+
+/// Versioned generated artifact for one imported model source.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct AnimationManifest {
+    pub schema_version: u32,
+    pub asset_id: String,
+    pub label: String,
+    pub source: AnimationManifestSource,
+    /// Whether this source format can hydrate the extracted animation data at runtime.
+    pub runtime_supported: bool,
+    #[serde(default)]
+    pub skeletons: Vec<AnimationSkeletonRecord>,
+    #[serde(default)]
+    pub clips: Vec<AnimationClipRecord>,
+    #[serde(default)]
+    pub diagnostics: Vec<AnimationImportDiagnostic>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AnimationManifestSource {
+    pub path: String,
+    pub format: String,
+    pub fingerprint: AnimationSourceFingerprint,
+    #[serde(default)]
+    pub dependencies: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AnimationSourceFingerprint {
+    pub byte_len: u64,
+    pub modified_unix_secs: u64,
+    /// BLAKE3 hash of the source file bytes.
+    pub content_hash: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AnimationSkeletonRecord {
+    /// Stable imported sub-asset ID used by [`EditorAssetRef`].
+    pub id: String,
+    pub label: String,
+    pub source_index: usize,
+    pub signature: AnimationSkeletonSignature,
+    /// Normalized root-to-joint target paths in source joint order.
+    pub joint_paths: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct AnimationClipRecord {
+    /// Stable imported sub-asset ID used by [`EditorAssetRef`].
+    pub id: String,
+    pub label: String,
+    pub source_index: usize,
+    pub duration_seconds: f32,
+    #[serde(default)]
+    pub target_skeleton_signature: Option<AnimationSkeletonSignature>,
+    #[serde(default)]
+    pub events: Vec<AnimationEventDesc>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AnimationDiagnosticSeverity {
+    Info,
+    Warning,
+    Error,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AnimationImportDiagnostic {
+    pub severity: AnimationDiagnosticSeverity,
+    pub code: String,
+    pub message: String,
+    pub repair: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn controller_defaults_are_single_layer_and_non_destructive() {
+        let controller = AnimationControllerDesc::default();
+        assert!(controller.skeleton.is_none());
+        assert!(controller.states.is_empty());
+        assert!(controller.default_state.is_empty());
+        assert_eq!(controller.default_crossfade_seconds, 0.2);
+    }
+
+    #[test]
+    fn authored_controller_round_trips_stable_refs_and_playback_settings() {
+        let controller = AnimationControllerDesc {
+            skeleton: Some(EditorAssetRef::new(
+                "model-id",
+                animation_skeleton_sub_asset_id(0, "Rig"),
+                "Rig",
+            )),
+            states: vec![AnimationStateDesc {
+                id: "locomotion.idle".into(),
+                label: "Idle".into(),
+                clip: EditorAssetRef::new(
+                    "model-id",
+                    animation_clip_sub_asset_id(2, "Idle"),
+                    "Idle",
+                ),
+                looping: true,
+                speed: 0.75,
+                range: AnimationPlaybackRange {
+                    start_seconds: 0.1,
+                    end_seconds: Some(1.2),
+                },
+            }],
+            default_state: "locomotion.idle".into(),
+            default_crossfade_seconds: 0.15,
+        };
+
+        let encoded = ron::to_string(&controller).unwrap();
+        let decoded: AnimationControllerDesc = ron::from_str(&encoded).unwrap();
+        assert_eq!(decoded, controller);
+        assert_eq!(decoded.state("locomotion.idle"), decoded.states.first());
+        assert!(decoded.state("missing").is_none());
+    }
+
+    #[test]
+    fn subasset_ids_encode_source_indices_deterministically() {
+        let clip = animation_clip_sub_asset_id(7, "Idle Loop");
+        let skeleton = animation_skeleton_sub_asset_id(3, "Hero Rig");
+        assert_eq!(clip, "animation:clip:7:idle_loop");
+        assert_eq!(skeleton, "animation:skeleton:3:hero_rig");
+        assert_eq!(animation_clip_source_index(&clip), Some(7));
+        assert_eq!(animation_skeleton_source_index(&skeleton), Some(3));
+        assert_eq!(animation_clip_source_index(&skeleton), None);
+    }
+}
diff --git a/crates/shared/src/components.rs b/crates/shared/src/components.rs
index 0c7743d..1b06190 100644
--- a/crates/shared/src/components.rs
+++ b/crates/shared/src/components.rs
@@ -15,6 +15,41 @@ impl ActorId {
     }
 }
 
+/// Stable scene-document identity and its authored subscene references.
+///
+/// This is persisted as a reflected scene resource. Cross-scene ownership never
+/// depends on runtime [`Entity`] identifiers.
+#[derive(Resource, Reflect, Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[reflect(Resource, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SceneComposition {
+    pub scene_id: String,
+    #[serde(default)]
+    pub subscenes: Vec<SubsceneReference>,
+}
+
+/// One stable, project-relative reference in a [`SceneComposition`].
+#[derive(Reflect, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubsceneReference {
+    pub id: String,
+    pub path: String,
+    #[serde(default = "default_true")]
+    pub visible: bool,
+    #[serde(default = "default_true")]
+    pub locked: bool,
+}
+
+impl Default for SubsceneReference {
+    fn default() -> Self {
+        Self {
+            id: String::new(),
+            path: String::new(),
+            visible: true,
+            locked: true,
+        }
+    }
+}
+
 /// User-facing actor display name, separate from Bevy's runtime [`Name`].
 #[derive(Component, Reflect, Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[reflect(Component, Default, Debug, PartialEq, Serialize, Deserialize)]
@@ -162,6 +197,11 @@ pub const COMPONENT_OBJECTIVE_MARKER: &str = "shared::components::ObjectiveMarke
 pub const COMPONENT_PREFAB_INSTANCE: &str = "shared::components::PrefabInstance";
 pub const COMPONENT_POST_PROCESS_VOLUME: &str = "shared::components::PostProcessVolumeDesc";
 pub const COMPONENT_PROJECT_SUN: &str = "shared::components::ProjectSun";
+pub const COMPONENT_AUDIO_SOURCE_DESC: &str = "shared::components::AudioSourceDesc";
+pub const COMPONENT_AUDIO_LISTENER_DESC: &str = "shared::components::AudioListenerDesc";
+
+/// Stable imported sub-asset identifier used by authored audio clip references.
+pub const AUDIO_CLIP_SUB_ASSET_ID: &str = "audio:source";
 
 /// Reference to an imported content-browser asset or sub-asset.
 #[derive(Reflect, Default, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -205,6 +245,135 @@ impl EditorAssetRef {
     }
 }
 
+/// Distance curve used by an authored spatial audio source.
+#[derive(Reflect, Default, Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AudioRolloff {
+    Linear,
+    #[default]
+    Inverse,
+    Exponential,
+}
+
+/// Serializable distance attenuation parameters for spatial audio playback.
+#[derive(Reflect, Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[reflect(Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AudioAttenuationDesc {
+    /// Radius in meters inside which the source plays at full gain.
+    #[serde(default = "default_audio_min_distance")]
+    pub min_distance: f32,
+    /// Radius in meters at which distance attenuation reaches silence.
+    #[serde(default = "default_audio_max_distance")]
+    pub max_distance: f32,
+    #[serde(default)]
+    pub rolloff: AudioRolloff,
+    /// Curve strength. `1.0` is the neutral authored value.
+    #[serde(default = "default_audio_rolloff_factor")]
+    pub rolloff_factor: f32,
+}
+
+impl Default for AudioAttenuationDesc {
+    fn default() -> Self {
+        Self {
+            min_distance: default_audio_min_distance(),
+            max_distance: default_audio_max_distance(),
+            rolloff: AudioRolloff::default(),
+            rolloff_factor: default_audio_rolloff_factor(),
+        }
+    }
+}
+
+fn default_audio_min_distance() -> f32 {
+    1.0
+}
+
+fn default_audio_max_distance() -> f32 {
+    25.0
+}
+
+fn default_audio_rolloff_factor() -> f32 {
+    1.0
+}
+
+fn default_audio_pitch() -> f32 {
+    1.0
+}
+
+fn default_audio_spatial_blend() -> f32 {
+    1.0
+}
+
+fn default_audio_bus() -> String {
+    settings::AUDIO_BUS_SFX_ID.to_string()
+}
+
+fn default_audio_ear_gap() -> f32 {
+    0.2
+}
+
+/// Scene-authored audio source. Runtime playback components are derived from this descriptor.
+#[derive(Component, Reflect, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[reflect(Component, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AudioSourceDesc {
+    #[serde(default)]
+    pub clip: Option<EditorAssetRef>,
+    /// Source gain in decibels before bus gain is applied.
+    #[serde(default)]
+    pub gain_db: f32,
+    #[serde(default = "default_audio_pitch")]
+    pub pitch: f32,
+    #[serde(default)]
+    pub looping: bool,
+    #[serde(default = "default_true")]
+    pub autoplay: bool,
+    /// Continuous authored blend where `0.0` is 2D and `1.0` is fully spatial.
+    #[serde(default = "default_audio_spatial_blend")]
+    pub spatial_blend: f32,
+    #[serde(default)]
+    pub attenuation: AudioAttenuationDesc,
+    /// Stable project audio bus ID.
+    #[serde(default = "default_audio_bus")]
+    pub bus: String,
+}
+
+impl Default for AudioSourceDesc {
+    fn default() -> Self {
+        Self {
+            clip: None,
+            gain_db: 0.0,
+            pitch: default_audio_pitch(),
+            looping: false,
+            autoplay: true,
+            spatial_blend: default_audio_spatial_blend(),
+            attenuation: AudioAttenuationDesc::default(),
+            bus: default_audio_bus(),
+        }
+    }
+}
+
+/// Scene-authored spatial listener. Runtime selection resolves enabled listeners by priority.
+#[derive(Component, Reflect, Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[reflect(Component, Default, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AudioListenerDesc {
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    #[serde(default)]
+    pub priority: i32,
+    /// Distance in meters between the listener's virtual ears.
+    #[serde(default = "default_audio_ear_gap")]
+    pub ear_gap: f32,
+}
+
+impl Default for AudioListenerDesc {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            priority: 0,
+            ear_gap: default_audio_ear_gap(),
+        }
+    }
+}
+
 /// Marker for entities that belong to editable/savable level data.
 #[derive(Component, Reflect, Default, Debug, Clone, Copy, Serialize, Deserialize)]
 #[reflect(Component, Default, Debug, Serialize, Deserialize)]
@@ -769,6 +938,9 @@ impl Default for MaterialDesc {
 #[derive(Component, Reflect, Default, Debug, Clone, Serialize, Deserialize)]
 #[reflect(Component, Default, Debug, Serialize, Deserialize)]
 pub struct ModelRef {
+    /// Stable asset-registry UUID. Empty only for legacy or unresolved references.
+    #[serde(default)]
+    pub asset_id: String,
     /// Asset path relative to `assets/`, e.g. `models/foo.glb` or `models/foo.fbx`.
     pub path: String,
     /// Scene index within the model file (`#SceneN` for FBX; glTF scene index otherwise).
@@ -778,11 +950,17 @@ pub struct ModelRef {
 impl ModelRef {
     pub fn new(path: impl Into<String>) -> Self {
         Self {
+            asset_id: String::new(),
             path: path.into(),
             scene_index: 0,
         }
     }
 
+    pub fn with_asset_id(mut self, asset_id: impl Into<String>) -> Self {
+        self.asset_id = asset_id.into();
+        self
+    }
+
     /// Asset-server path for FBX `#SceneN` labels (see `bevy_ufbx`).
     pub fn fbx_scene_asset_path(path: &str, scene_index: usize) -> String {
         format!("{path}#Scene{scene_index}")
@@ -791,7 +969,7 @@ impl ModelRef {
 
 /// Reflectable reference to a saved `.scn.ron` dynamic scene under `assets/`.
 /// Hydration turns this into a `DynamicWorldRoot`.
-#[derive(Component, Reflect, Default, Debug, Clone, Serialize, Deserialize)]
+#[derive(Component, Reflect, Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[reflect(Component, Default, Debug, Serialize, Deserialize)]
 pub struct PrefabRef {
     /// Asset path relative to `assets/`, e.g. "prefabs/foo.scn.ron".
@@ -805,7 +983,7 @@ impl PrefabRef {
 }
 
 /// Marks a placed prefab instance with stable registry identity.
-#[derive(Component, Reflect, Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Component, Reflect, Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[reflect(Component, Default, Debug, Serialize, Deserialize)]
 pub struct PrefabInstance {
     /// Stable asset registry UUID string.
@@ -950,7 +1128,7 @@ pub struct ObjectiveMarker {
 pub struct HierarchySiblingIndex(pub i32);
 
 /// Authoring visibility saved with the scene; hydration maps this to ECS [`Visibility`].
-#[derive(Component, Reflect, Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(Component, Reflect, Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[reflect(Component, Default, Debug, Serialize, Deserialize)]
 pub struct EditorVisibility {
     pub visible: bool,
@@ -978,6 +1156,8 @@ pub enum ActorKind {
     PostProcessVolume,
     TeamSpawn,
     Objective,
+    AudioSource,
+    AudioListener,
 }
 
 /// Inspector upper bound for point/spot [`LightDesc::intensity`] (lumens).
@@ -1251,7 +1431,10 @@ impl Default for PhysicsBody {
 
 #[cfg(test)]
 mod tests {
-    use super::ModelRef;
+    use super::{
+        AudioListenerDesc, AudioRolloff, AudioSourceDesc, EditorAssetRef, ModelRef,
+        AUDIO_CLIP_SUB_ASSET_ID,
+    };
     use bevy::light::light_consts;
 
     #[test]
@@ -1275,4 +1458,41 @@ mod tests {
             "models/foo.fbx#Scene2"
         );
     }
+
+    #[test]
+    fn legacy_model_ref_without_asset_id_remains_readable() {
+        let model: ModelRef = ron::from_str(
+            r#"(
+                path: "assets/models/legacy.glb",
+                scene_index: 2,
+            )"#,
+        )
+        .expect("legacy ModelRef should deserialize");
+
+        assert!(model.asset_id.is_empty());
+        assert_eq!(model.path, "assets/models/legacy.glb");
+        assert_eq!(model.scene_index, 2);
+    }
+
+    #[test]
+    fn audio_authoring_descriptors_round_trip() {
+        let source = AudioSourceDesc {
+            clip: Some(
+                EditorAssetRef::new("clip-id", AUDIO_CLIP_SUB_ASSET_ID, "Alarm")
+                    .with_source_path("assets/audio/alarm.ogg"),
+            ),
+            gain_db: -3.0,
+            pitch: 0.9,
+            looping: true,
+            ..Default::default()
+        };
+        let serialized = ron::to_string(&(source.clone(), AudioListenerDesc::default())).unwrap();
+        let (parsed_source, parsed_listener): (AudioSourceDesc, AudioListenerDesc) =
+            ron::from_str(&serialized).unwrap();
+
+        assert_eq!(parsed_source, source);
+        assert_eq!(parsed_listener, AudioListenerDesc::default());
+        assert_eq!(parsed_source.attenuation.rolloff, AudioRolloff::Inverse);
+        assert_eq!(parsed_source.bus, settings::AUDIO_BUS_SFX_ID);
+    }
 }
diff --git a/crates/shared/src/hydration/mod.rs b/crates/shared/src/hydration/mod.rs
index 650027c..7c26c3d 100644
--- a/crates/shared/src/hydration/mod.rs
+++ b/crates/shared/src/hydration/mod.rs
@@ -22,8 +22,10 @@ use lights::{hydrate_lights, reconcile_missing_runtime_lights};
 use materials::hydrate_materials;
 pub use materials::material_from_desc;
 use models::hydrate_models;
+pub use models::HydratedModelRoot;
 use physics::hydrate_physics;
-use prefabs::hydrate_prefabs;
+use prefabs::{hydrate_prefabs, tag_hydrated_prefab_members};
+pub use prefabs::{HydratedPrefabMember, HydratedPrefabReady, PrefabHydrationBlocked};
 use primitives::{hydrate_primitives, primitive_mesh};
 use static_meshes::{
     hydrate_static_mesh_renderers, spawn_static_mesh_parts, HydratedStaticMeshPart,
@@ -47,6 +49,8 @@ pub struct HydrationPlugin;
 impl Plugin for HydrationPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<StaticMeshArtifactCache>()
+            .add_observer(tag_hydrated_prefab_members)
+            .add_observer(crate::prefab_overrides::apply_prefab_overrides_on_ready)
             .add_systems(
                 Update,
                 (
diff --git a/crates/shared/src/hydration/models.rs b/crates/shared/src/hydration/models.rs
index 1022313..653c9d5 100644
--- a/crates/shared/src/hydration/models.rs
+++ b/crates/shared/src/hydration/models.rs
@@ -6,7 +6,13 @@ use bevy::prelude::*;
 
 use crate::{asset_server_path, LevelObject, ModelRef};
 
-use super::strip::despawn_generated_children;
+use super::static_meshes::static_mesh_source_path;
+
+/// Runtime root generated for one authored [`ModelRef`].
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct HydratedModelRoot {
+    pub owner: Entity,
+}
 
 #[allow(clippy::type_complexity)]
 pub fn hydrate_models(
@@ -16,21 +22,194 @@ pub fn hydrate_models(
         (Entity, &ModelRef),
         (With<LevelObject>, Or<(Added<ModelRef>, Changed<ModelRef>)>),
     >,
-    children: Query<&Children>,
+    generated_roots: Query<(Entity, &HydratedModelRoot)>,
 ) {
     for (entity, model) in &models {
-        if let Ok(child_list) = children.get(entity) {
-            despawn_generated_children(&mut commands, entity, child_list);
+        for (root, generated) in &generated_roots {
+            if generated.owner == entity {
+                commands.entity(root).despawn();
+            }
         }
 
+        // Remove roots created by the legacy hydration path without touching authored children.
         commands.entity(entity).remove::<WorldAssetRoot>();
 
-        let path = asset_server_path(&model.path);
+        let resolved_path = if model.asset_id.trim().is_empty() {
+            model.path.clone()
+        } else {
+            match static_mesh_source_path(&model.asset_id) {
+                Ok(path) => path,
+                Err(error) => {
+                    warn!(
+                        "ModelRef {} could not resolve stable asset {}: {error}; falling back to cached path {}",
+                        entity,
+                        model.asset_id,
+                        model.path
+                    );
+                    model.path.clone()
+                }
+            }
+        };
+        let path = asset_server_path(&resolved_path);
         let handle = if path.ends_with(".fbx") {
             asset_server.load(ModelRef::fbx_scene_asset_path(&path, model.scene_index))
         } else {
             asset_server.load(GltfAssetLabel::Scene(model.scene_index).from_asset(path))
         };
-        commands.entity(entity).insert(WorldAssetRoot(handle));
+        commands.spawn((
+            Name::new("Hydrated Imported Model Root"),
+            HydratedModelRoot { owner: entity },
+            WorldAssetRoot(handle),
+            ChildOf(entity),
+        ));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::{AssetApp, AssetPlugin};
+    use bevy::prelude::WorldAsset;
+    use std::path::{Path, PathBuf};
+
+    struct TestManifest(PathBuf);
+
+    impl Drop for TestManifest {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_file(&self.0);
+        }
+    }
+
+    fn write_test_manifest(asset_id: &str, source_path: &str) -> TestManifest {
+        let path = PathBuf::from(super::super::static_meshes::static_mesh_manifest_path(
+            asset_id,
+        ));
+        std::fs::create_dir_all(path.parent().expect("manifest has a parent directory"))
+            .expect("generated static mesh directory should be writable");
+        std::fs::write(
+            &path,
+            format!(
+                r#"(
+                    source: (path: "{source_path}"),
+                    parts: [],
+                )"#
+            ),
+        )
+        .expect("test static mesh manifest should be writable");
+        TestManifest(path)
+    }
+
+    fn hydration_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((MinimalPlugins, AssetPlugin::default()))
+            .init_asset::<WorldAsset>()
+            .add_systems(Update, hydrate_models);
+        app
+    }
+
+    fn generated_roots(world: &mut World, owner: Entity) -> Vec<Entity> {
+        world
+            .query::<(Entity, &HydratedModelRoot)>()
+            .iter(world)
+            .filter_map(|(entity, generated)| (generated.owner == owner).then_some(entity))
+            .collect()
+    }
+
+    #[test]
+    fn hydration_preserves_arbitrary_authored_children() {
+        let mut app = hydration_app();
+        let owner = app
+            .world_mut()
+            .spawn((LevelObject, ModelRef::new("assets/models/first.glb")))
+            .id();
+        let authored_child = app
+            .world_mut()
+            .spawn((Name::new("Authored Child"), ChildOf(owner)))
+            .id();
+
+        app.update();
+
+        assert!(app.world().get_entity(authored_child).is_ok());
+        assert_eq!(
+            app.world().get::<ChildOf>(authored_child).unwrap().parent(),
+            owner
+        );
+        assert_eq!(generated_roots(app.world_mut(), owner).len(), 1);
+    }
+
+    #[test]
+    fn model_ref_change_replaces_only_the_generated_root() {
+        let mut app = hydration_app();
+        let owner = app
+            .world_mut()
+            .spawn((LevelObject, ModelRef::new("assets/models/first.glb")))
+            .id();
+        let authored_child = app
+            .world_mut()
+            .spawn((Name::new("Authored Child"), ChildOf(owner)))
+            .id();
+
+        app.update();
+        let first_root = generated_roots(app.world_mut(), owner)
+            .into_iter()
+            .next()
+            .unwrap();
+
+        app.world_mut().get_mut::<ModelRef>(owner).unwrap().path =
+            "assets/models/second.glb".into();
+        app.update();
+
+        let roots = generated_roots(app.world_mut(), owner);
+        assert_eq!(roots.len(), 1);
+        assert_ne!(roots[0], first_root);
+        assert!(app.world().get_entity(first_root).is_err());
+        assert!(app.world().get_entity(authored_child).is_ok());
+        assert_eq!(
+            app.world().get::<ChildOf>(authored_child).unwrap().parent(),
+            owner
+        );
+    }
+
+    #[test]
+    fn stable_asset_id_resolves_relocated_model_source_from_manifest() {
+        const ASSET_ID: &str = "34b80e75-f00c-4ead-91cb-54bd9b66ad55";
+        const CACHED_PATH: &str = "assets/models/stale_cached_path.glb";
+        const MANIFEST_PATH: &str = "assets/models/relocated/source.glb";
+        let _manifest = write_test_manifest(ASSET_ID, MANIFEST_PATH);
+        let mut app = hydration_app();
+        let owner = app
+            .world_mut()
+            .spawn((
+                LevelObject,
+                ModelRef {
+                    asset_id: ASSET_ID.into(),
+                    path: CACHED_PATH.into(),
+                    scene_index: 3,
+                },
+            ))
+            .id();
+
+        app.update();
+
+        let root_entity = generated_roots(app.world_mut(), owner)
+            .into_iter()
+            .next()
+            .expect("stable model reference should create a hydrated root");
+        let root = app
+            .world()
+            .get::<WorldAssetRoot>(root_entity)
+            .expect("generated root should retain its world asset handle");
+        let loaded_path = app
+            .world()
+            .resource::<AssetServer>()
+            .get_path(root.0.id())
+            .expect("world asset handle should retain its resolved source path");
+
+        assert_eq!(loaded_path.path(), Path::new("models/relocated/source.glb"));
+        assert_eq!(loaded_path.label(), Some("Scene3"));
+        assert_ne!(
+            loaded_path.path(),
+            Path::new("models/stale_cached_path.glb")
+        );
     }
 }
diff --git a/crates/shared/src/hydration/prefabs.rs b/crates/shared/src/hydration/prefabs.rs
index 007ccdc..79ab79b 100644
--- a/crates/shared/src/hydration/prefabs.rs
+++ b/crates/shared/src/hydration/prefabs.rs
@@ -2,11 +2,28 @@
 
 use bevy::prelude::DynamicWorldRoot;
 use bevy::prelude::*;
+use bevy::world_serialization::{WorldInstanceReady, WorldInstanceSpawner};
 
 use crate::{LevelObject, PrefabInstance, PrefabRef};
 
 use crate::asset_server_path;
 
+/// Runtime ownership for entities spawned from a linked prefab source.
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct HydratedPrefabMember {
+    pub instance_root: Entity,
+}
+
+/// Runtime marker that the linked prefab instance finished spawning.
+#[derive(Component, Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct HydratedPrefabReady;
+
+/// Runtime-only guard used by editor recovery when a prefab source is invalid.
+#[derive(Component, Debug, Clone, PartialEq, Eq)]
+pub struct PrefabHydrationBlocked {
+    pub reason: String,
+}
+
 #[allow(clippy::type_complexity)]
 pub fn hydrate_prefabs(
     mut commands: Commands,
@@ -23,21 +40,89 @@ pub fn hydrate_prefabs(
         (Entity, &PrefabInstance),
         (
             With<LevelObject>,
+            Without<PrefabHydrationBlocked>,
             Or<(Added<PrefabInstance>, Changed<PrefabInstance>)>,
         ),
     >,
 ) {
     for (entity, prefab) in &prefabs {
-        commands.entity(entity).insert(DynamicWorldRoot(
-            asset_server.load(asset_server_path(&prefab.path)),
+        commands.entity(entity).insert(PrefabInstance::new(
+            format!("legacy:{}", prefab.path),
+            prefab.path.clone(),
         ));
     }
 
     for (entity, instance) in &prefab_instances {
         let path = asset_server_path(&instance.source_path);
-        commands.entity(entity).insert((
-            PrefabRef::new(instance.source_path.clone()),
-            DynamicWorldRoot(asset_server.load(path)),
-        ));
+        commands
+            .entity(entity)
+            .remove::<HydratedPrefabReady>()
+            .insert((
+                PrefabRef::new(instance.source_path.clone()),
+                DynamicWorldRoot(asset_server.load(path)),
+            ));
+    }
+}
+
+pub fn tag_hydrated_prefab_members(
+    ready: On<WorldInstanceReady>,
+    prefab_roots: Query<(), With<PrefabInstance>>,
+    instance_spawner: Res<WorldInstanceSpawner>,
+    mut commands: Commands,
+) {
+    if prefab_roots.get(ready.entity).is_err() {
+        return;
+    }
+    for member in instance_spawner.iter_instance_entities(ready.instance_id) {
+        commands.entity(member).insert(HydratedPrefabMember {
+            instance_root: ready.entity,
+        });
+    }
+    commands.entity(ready.entity).insert(HydratedPrefabReady);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::AssetPlugin;
+    use bevy::world_serialization::{DynamicWorld, WorldSerializationPlugin};
+
+    #[test]
+    fn spawned_prefab_entities_receive_runtime_ownership() {
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), WorldSerializationPlugin))
+            .register_type::<crate::LevelObject>()
+            .register_type::<crate::ActorId>()
+            .add_observer(tag_hydrated_prefab_members);
+
+        let mut source = World::new();
+        source.spawn((crate::LevelObject, crate::ActorId::new("child")));
+        let dynamic_world = DynamicWorld::from_world_with(
+            &source,
+            &app.world().resource::<AppTypeRegistry>().read(),
+        );
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(dynamic_world);
+        let root = app
+            .world_mut()
+            .spawn((
+                PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron"),
+                DynamicWorldRoot(handle),
+            ))
+            .id();
+
+        app.update();
+
+        let world = app.world_mut();
+        let members: Vec<_> = world
+            .query::<(Entity, &HydratedPrefabMember)>()
+            .iter(world)
+            .map(|(entity, owner)| (entity, owner.instance_root))
+            .collect();
+        assert_eq!(members.len(), 1);
+        assert_eq!(members[0].1, root);
+        assert!(world.get::<HydratedPrefabReady>(root).is_some());
     }
 }
diff --git a/crates/shared/src/hydration/static_meshes.rs b/crates/shared/src/hydration/static_meshes.rs
index 259a17c..65b5c2e 100644
--- a/crates/shared/src/hydration/static_meshes.rs
+++ b/crates/shared/src/hydration/static_meshes.rs
@@ -7,9 +7,9 @@ use serde::Deserialize;
 use std::collections::{HashMap, HashSet};
 
 use crate::{
-    asset_server_path, inspector_component_active, ColliderDesc, ColliderShapeDesc, EditorAssetRef,
-    InspectorOrder, LevelObject, MaterialDesc, MaterialOverride, StaticMeshRenderer,
-    StaticMeshRendererEntry, COMPONENT_COLLIDER_DESC, COMPONENT_MATERIAL_DESC,
+    asset_server_path, inspector_component_active, standard_material_asset_path, ColliderDesc,
+    ColliderShapeDesc, EditorAssetRef, InspectorOrder, LevelObject, MaterialDesc, MaterialOverride,
+    StaticMeshRenderer, StaticMeshRendererEntry, COMPONENT_COLLIDER_DESC, COMPONENT_MATERIAL_DESC,
     COMPONENT_STATIC_MESH_RENDERER,
 };
 
@@ -318,7 +318,7 @@ fn material_for_entry(
     if let Some(material_ref) = entry.material.as_ref() {
         if let Some(resolved_material) = artifact_cache.resolve_material(material_ref) {
             let source_path = asset_server_path(&resolved_material.source_path);
-            return asset_server.load(labeled_asset_path(
+            return asset_server.load(standard_material_asset_path(
                 &source_path,
                 &resolved_material.material_label,
             ));
@@ -331,7 +331,7 @@ fn material_for_entry(
 
     if let Some(label) = resolved.material_label.as_deref() {
         let source_path = asset_server_path(&resolved.source_path);
-        return asset_server.load(labeled_asset_path(&source_path, label));
+        return asset_server.load(standard_material_asset_path(&source_path, label));
     }
 
     materials.add(StandardMaterial::default())
@@ -361,6 +361,18 @@ pub fn static_mesh_manifest_path(asset_id: &str) -> String {
     format!("{STATIC_MESH_ARTIFACT_DIR}/{asset_id}.static_mesh.ron")
 }
 
+pub(super) fn static_mesh_source_path(asset_id: &str) -> Result<String, String> {
+    let path = static_mesh_manifest_path(asset_id);
+    let text = std::fs::read_to_string(&path)
+        .map_err(|error| format!("could not read {path}: {error}"))?;
+    let manifest: StaticMeshResolveManifest =
+        ron::from_str(&text).map_err(|error| format!("could not parse {path}: {error}"))?;
+    if manifest.source.path.trim().is_empty() {
+        return Err(format!("static mesh manifest {path} has no source path"));
+    }
+    Ok(manifest.source.path)
+}
+
 fn part_id_from_label(label: &str) -> String {
     format!("mesh:{}", stable_sub_asset_slug(label))
 }
diff --git a/crates/shared/src/hydration/strip.rs b/crates/shared/src/hydration/strip.rs
index 3140d99..387e36d 100644
--- a/crates/shared/src/hydration/strip.rs
+++ b/crates/shared/src/hydration/strip.rs
@@ -30,11 +30,3 @@ pub fn strip_hydrated(entity_commands: &mut EntityCommands<'_>) {
         .remove::<RigidBody>()
         .remove::<Collider>();
 }
-
-/// Despawns all child entities (e.g. prior `WorldAssetRoot` instance hierarchy).
-pub fn despawn_generated_children(commands: &mut Commands, entity: Entity, children: &Children) {
-    for child in children.iter() {
-        commands.entity(child).despawn();
-    }
-    commands.entity(entity).remove::<Children>();
-}
diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
index 463ae0c..f1dcf4c 100644
--- a/crates/shared/src/lib.rs
+++ b/crates/shared/src/lib.rs
@@ -5,23 +5,32 @@
 //! from them by hydration systems in both the game and editor.
 
 mod actor;
+mod animation;
 pub mod brush_math;
 mod components;
 mod hydration;
 mod material_asset;
 mod post_process_effect_asset;
+mod prefab_overrides;
 mod rendering_profile_asset;
 
 pub use actor::{infer_actor_kind, validate_actor, ActorValidationError};
+pub use animation::*;
 pub use components::*;
 pub use hydration::{
     cascade_config_from_rendering, flush_level_object_hydration, material_from_desc,
-    strip_hydrated, strip_hydrated_entity, HydrationPlugin,
+    strip_hydrated, strip_hydrated_entity, HydratedModelRoot, HydratedPrefabMember,
+    HydratedPrefabReady, HydrationPlugin, PrefabHydrationBlocked,
 };
 pub use material_asset::{
     MaterialAsset, ShaderPropertyDesc, ShaderPropertyType, ShaderSchemaAsset,
 };
 pub use post_process_effect_asset::{PostProcessEffectAsset, PostProcessEffectKind};
+pub use prefab_overrides::{
+    apply_prefab_overrides_on_ready, decode_prefab_overrides, encode_prefab_overrides,
+    PrefabActorPath, PrefabComponentOverride, PrefabOverrides, PrefabPropertyOverride,
+    PrefabStructuralOverride, PREFAB_OVERRIDE_FORMAT_VERSION,
+};
 pub use rendering_profile_asset::RenderingProfileAsset;
 
 /// Converts catalog-style paths (`assets/models/foo.fbx`) to Bevy AssetServer paths.
@@ -33,6 +42,23 @@ pub fn asset_server_path(catalog_path: &str) -> String {
         .unwrap_or(normalized)
 }
 
+/// Returns the typed [`StandardMaterial`] asset path for a source material label.
+///
+/// Bevy's glTF loader owns `#MaterialN` as a `GltfMaterial`; the PBR extension
+/// publishes its renderable conversion under the nested `#MaterialN/std` label.
+/// Other model loaders, including `bevy_ufbx`, expose `StandardMaterial` at the
+/// original label.
+pub fn standard_material_asset_path(asset_path: &str, material_label: &str) -> String {
+    let lower_path = asset_path.to_ascii_lowercase();
+    let gltf_source = lower_path.ends_with(".gltf") || lower_path.ends_with(".glb");
+    let label = if gltf_source && !material_label.ends_with("/std") {
+        format!("{material_label}/std")
+    } else {
+        material_label.to_string()
+    };
+    format!("{asset_path}#{label}")
+}
+
 use bevy::prelude::*;
 
 /// Registers all reflectable authoring types and installs hydration systems.
@@ -43,11 +69,22 @@ impl Plugin for SharedTypesPlugin {
         app.register_type::<ActorKind>()
             .register_type::<ActorId>()
             .register_type::<ActorName>()
+            .register_type::<SceneComposition>()
+            .register_type::<SubsceneReference>()
             .register_type::<HierarchySiblingIndex>()
             .register_type::<InspectorOrder>()
             .register_type::<InspectorComponentState>()
             .register_type::<ComponentInstanceId>()
             .register_type::<EditorAssetRef>()
+            .register_type::<AnimationSkeletonSignature>()
+            .register_type::<AnimationPlaybackRange>()
+            .register_type::<AnimationEventDesc>()
+            .register_type::<AnimationStateDesc>()
+            .register_type::<AnimationControllerDesc>()
+            .register_type::<AudioSourceDesc>()
+            .register_type::<AudioListenerDesc>()
+            .register_type::<AudioAttenuationDesc>()
+            .register_type::<AudioRolloff>()
             .register_type::<EditorVisibility>()
             .register_type::<LevelObject>()
             .register_type::<RaytracingExcluded>()
@@ -93,3 +130,36 @@ impl Plugin for SharedTypesPlugin {
             .add_plugins(HydrationPlugin);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::standard_material_asset_path;
+
+    #[test]
+    fn gltf_standard_material_paths_use_pbr_conversion_label() {
+        assert_eq!(
+            standard_material_asset_path("models/robot.gltf", "Material3"),
+            "models/robot.gltf#Material3/std"
+        );
+        assert_eq!(
+            standard_material_asset_path("models/robot.GLB", "DefaultMaterial"),
+            "models/robot.GLB#DefaultMaterial/std"
+        );
+    }
+
+    #[test]
+    fn non_gltf_material_paths_keep_loader_label() {
+        assert_eq!(
+            standard_material_asset_path("models/robot.fbx", "Material3"),
+            "models/robot.fbx#Material3"
+        );
+    }
+
+    #[test]
+    fn converted_gltf_material_label_is_not_suffixed_twice() {
+        assert_eq!(
+            standard_material_asset_path("models/robot.glb", "Material3/std"),
+            "models/robot.glb#Material3/std"
+        );
+    }
+}
diff --git a/crates/shared/src/prefab_overrides.rs b/crates/shared/src/prefab_overrides.rs
new file mode 100644
index 0000000..352db89
--- /dev/null
+++ b/crates/shared/src/prefab_overrides.rs
@@ -0,0 +1,705 @@
+//! Versioned prefab override data and runtime application.
+
+use std::collections::{HashMap, HashSet};
+
+use bevy::ecs::reflect::ReflectComponent;
+use bevy::prelude::*;
+use bevy::reflect::serde::TypedReflectDeserializer;
+use bevy::reflect::{GetPath, ParsedPath, ReflectPath};
+use bevy::world_serialization::{WorldInstanceReady, WorldInstanceSpawner};
+use serde::de::DeserializeSeed;
+use serde::{Deserialize, Serialize};
+
+use crate::{ActorId, EditorVisibility, HydratedPrefabMember, MaterialDesc, PrefabInstance};
+
+pub const PREFAB_OVERRIDE_FORMAT_VERSION: u32 = 2;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct PrefabActorPath {
+    #[serde(default)]
+    pub instance_chain: Vec<String>,
+    pub actor_id: String,
+}
+
+impl PrefabActorPath {
+    pub fn direct(actor_id: impl Into<String>) -> Self {
+        Self {
+            instance_chain: Vec::new(),
+            actor_id: actor_id.into(),
+        }
+    }
+
+    fn belongs_to_layer(&self, instance_chain: &[String]) -> bool {
+        self.instance_chain == instance_chain
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct PrefabPropertyOverride {
+    pub target: PrefabActorPath,
+    pub component_type: String,
+    /// Bevy reflection path within the component, such as `base_color.r`.
+    pub property_path: String,
+    /// Full component value observed when the override was created.
+    pub base_component_ron: String,
+    /// Full component value containing the overridden property.
+    pub value_component_ron: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct PrefabComponentOverride {
+    pub target: PrefabActorPath,
+    pub component_type: String,
+    /// Source component value, or `None` when this component was locally added.
+    pub base_component_ron: Option<String>,
+    /// Replacement component value, or `None` to remove the source component.
+    pub value_component_ron: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub enum PrefabStructuralOverride {
+    RemoveChild {
+        target: PrefabActorPath,
+        base_subtree_revision: String,
+    },
+    ReparentChild {
+        target: PrefabActorPath,
+        base_parent: Option<PrefabActorPath>,
+        new_parent: Option<PrefabActorPath>,
+        /// Source transform observed when the structural override was authored.
+        #[serde(default)]
+        base_transform_ron: Option<String>,
+        /// Local transform after reparenting, preserving the authored world-space pose.
+        #[serde(default)]
+        local_transform_ron: Option<String>,
+    },
+    AttachLocalChild {
+        local_actor_id: String,
+        parent: PrefabActorPath,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct PrefabOverrides {
+    #[serde(default = "default_format_version")]
+    pub format_version: u32,
+    #[serde(default)]
+    pub source_revision: Option<String>,
+    /// Legacy anchor override retained for wire compatibility. New authoring does not emit it.
+    #[serde(default)]
+    pub transform: Option<Transform>,
+    /// Legacy anchor override retained for wire compatibility. New authoring does not emit it.
+    #[serde(default)]
+    pub material: Option<MaterialDesc>,
+    /// V1 direct-child visibility overrides, keyed by ActorId.
+    #[serde(default)]
+    pub child_visibility: HashMap<String, bool>,
+    #[serde(default)]
+    pub properties: Vec<PrefabPropertyOverride>,
+    #[serde(default)]
+    pub components: Vec<PrefabComponentOverride>,
+    #[serde(default)]
+    pub structural: Vec<PrefabStructuralOverride>,
+}
+
+impl Default for PrefabOverrides {
+    fn default() -> Self {
+        Self {
+            format_version: PREFAB_OVERRIDE_FORMAT_VERSION,
+            source_revision: None,
+            transform: None,
+            material: None,
+            child_visibility: HashMap::new(),
+            properties: Vec::new(),
+            components: Vec::new(),
+            structural: Vec::new(),
+        }
+    }
+}
+
+const fn default_format_version() -> u32 {
+    1
+}
+
+pub fn decode_prefab_overrides(instance: &PrefabInstance) -> Result<PrefabOverrides, String> {
+    instance.overrides_ron.as_ref().map_or_else(
+        || Ok(PrefabOverrides::default()),
+        |text| {
+            let overrides: PrefabOverrides = ron::from_str(text)
+                .map_err(|error| format!("invalid prefab override data: {error}"))?;
+            validate_prefab_overrides_payload(&overrides)?;
+            Ok(overrides)
+        },
+    )
+}
+
+pub fn validate_prefab_overrides_payload(overrides: &PrefabOverrides) -> Result<(), String> {
+    if !(1..=PREFAB_OVERRIDE_FORMAT_VERSION).contains(&overrides.format_version) {
+        return Err(format!(
+            "unsupported prefab override format version {}",
+            overrides.format_version
+        ));
+    }
+    for property in &overrides.properties {
+        ron::from_str::<ron::Value>(&property.base_component_ron).map_err(|error| {
+            format!(
+                "invalid base value for `{}`: {error}",
+                property.component_type
+            )
+        })?;
+        ron::from_str::<ron::Value>(&property.value_component_ron).map_err(|error| {
+            format!(
+                "invalid override value for `{}`: {error}",
+                property.component_type
+            )
+        })?;
+        ParsedPath::parse(&property.property_path).map_err(|error| {
+            format!(
+                "invalid property path `{}`: {error}",
+                property.property_path
+            )
+        })?;
+    }
+    for component in &overrides.components {
+        for value in [
+            component.base_component_ron.as_deref(),
+            component.value_component_ron.as_deref(),
+        ]
+        .into_iter()
+        .flatten()
+        {
+            ron::from_str::<ron::Value>(value).map_err(|error| {
+                format!(
+                    "invalid component value for `{}`: {error}",
+                    component.component_type
+                )
+            })?;
+        }
+    }
+    for structural in &overrides.structural {
+        if let PrefabStructuralOverride::ReparentChild {
+            base_transform_ron,
+            local_transform_ron,
+            ..
+        } = structural
+        {
+            for value in [
+                base_transform_ron.as_deref(),
+                local_transform_ron.as_deref(),
+            ]
+            .into_iter()
+            .flatten()
+            {
+                ron::from_str::<Transform>(value)
+                    .map_err(|error| format!("invalid reparent transform: {error}"))?;
+            }
+        }
+    }
+    Ok(())
+}
+
+pub fn encode_prefab_overrides(overrides: &PrefabOverrides) -> Result<Option<String>, String> {
+    if overrides == &PrefabOverrides::default() {
+        Ok(None)
+    } else {
+        ron::to_string(overrides)
+            .map(Some)
+            .map_err(|error| format!("could not encode prefab overrides: {error}"))
+    }
+}
+
+pub fn apply_prefab_overrides_on_ready(
+    ready: On<WorldInstanceReady>,
+    roots: Query<&PrefabInstance>,
+    owners: Query<&HydratedPrefabMember>,
+    actor_ids: Query<&ActorId>,
+    instance_spawner: Res<WorldInstanceSpawner>,
+    mut commands: Commands,
+) {
+    let members: HashMap<String, Entity> = instance_spawner
+        .iter_instance_entities(ready.instance_id)
+        .filter_map(|entity| {
+            actor_ids
+                .get(entity)
+                .ok()
+                .map(|actor_id| (actor_id.0.clone(), entity))
+        })
+        .collect();
+    if members.is_empty() {
+        return;
+    }
+
+    let mut current = ready.entity;
+    let mut instance_chain = Vec::new();
+    let mut seen = HashSet::new();
+    while seen.insert(current) {
+        if let Ok(instance) = roots.get(current) {
+            match decode_prefab_overrides(instance) {
+                Ok(overrides) => {
+                    let members = members.clone();
+                    let chain = instance_chain.clone();
+                    let owner_root = current;
+                    commands.queue(move |world: &mut World| {
+                        if let Err(error) =
+                            apply_override_layer(world, owner_root, &chain, &members, &overrides)
+                        {
+                            warn!("Could not apply prefab overrides: {error}");
+                        }
+                    });
+                }
+                Err(error) => warn!("Skipping malformed prefab overrides: {error}"),
+            }
+        }
+
+        let Ok(owner) = owners.get(current) else {
+            break;
+        };
+        let Ok(actor_id) = actor_ids.get(current) else {
+            break;
+        };
+        instance_chain.insert(0, actor_id.0.clone());
+        current = owner.instance_root;
+    }
+}
+
+fn apply_override_layer(
+    world: &mut World,
+    owner_root: Entity,
+    instance_chain: &[String],
+    members: &HashMap<String, Entity>,
+    overrides: &PrefabOverrides,
+) -> Result<(), String> {
+    let mut errors = Vec::new();
+    if instance_chain.is_empty() {
+        for (actor_id, visible) in &overrides.child_visibility {
+            if let Some(entity) = members.get(actor_id).copied() {
+                if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+                    entity_mut.insert(EditorVisibility { visible: *visible });
+                }
+            }
+        }
+    }
+
+    for structural in &overrides.structural {
+        if !matches!(structural, PrefabStructuralOverride::ReparentChild { .. }) {
+            continue;
+        }
+        if let Err(error) =
+            apply_structural_override(world, owner_root, instance_chain, members, structural)
+        {
+            errors.push(error);
+        }
+    }
+
+    for component in &overrides.components {
+        if !component.target.belongs_to_layer(instance_chain) {
+            continue;
+        }
+        let Some(entity) = members.get(&component.target.actor_id).copied() else {
+            continue;
+        };
+        if let Err(error) = apply_component_override(world, entity, component) {
+            errors.push(error);
+        }
+    }
+    for property in &overrides.properties {
+        if !property.target.belongs_to_layer(instance_chain) {
+            continue;
+        }
+        let Some(entity) = members.get(&property.target.actor_id).copied() else {
+            continue;
+        };
+        if let Err(error) = apply_property_override(world, entity, property) {
+            errors.push(error);
+        }
+    }
+    for structural in &overrides.structural {
+        if matches!(structural, PrefabStructuralOverride::ReparentChild { .. }) {
+            continue;
+        }
+        if let Err(error) =
+            apply_structural_override(world, owner_root, instance_chain, members, structural)
+        {
+            errors.push(error);
+        }
+    }
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(errors.join("; "))
+    }
+}
+
+fn apply_component_override(
+    world: &mut World,
+    entity: Entity,
+    component: &PrefabComponentOverride,
+) -> Result<(), String> {
+    if world.get_entity(entity).is_err() {
+        return Err(format!(
+            "component override target {:?} no longer exists",
+            entity
+        ));
+    }
+    world.resource_scope(|world, registry: Mut<AppTypeRegistry>| {
+        let registry = registry.read();
+        let registration = registry
+            .get_with_type_path(&component.component_type)
+            .ok_or_else(|| {
+                format!(
+                    "component type `{}` is not registered",
+                    component.component_type
+                )
+            })?;
+        let reflect_component = registration
+            .data::<ReflectComponent>()
+            .cloned()
+            .ok_or_else(|| {
+                format!(
+                    "component `{}` is not reflectable",
+                    component.component_type
+                )
+            })?;
+        match component.value_component_ron.as_deref() {
+            Some(value) => {
+                let reflected = deserialize_component(value, registration, &registry)?;
+                let exists = reflect_component.reflect(world.entity(entity)).is_some();
+                if exists {
+                    reflect_component.apply(world.entity_mut(entity), reflected.as_ref());
+                } else {
+                    reflect_component.insert(
+                        &mut world.entity_mut(entity),
+                        reflected.as_ref(),
+                        &registry,
+                    );
+                }
+            }
+            None => reflect_component.remove(&mut world.entity_mut(entity)),
+        }
+        Ok(())
+    })
+}
+
+fn apply_property_override(
+    world: &mut World,
+    entity: Entity,
+    property: &PrefabPropertyOverride,
+) -> Result<(), String> {
+    if world.get_entity(entity).is_err() {
+        return Err(format!(
+            "property override target {:?} no longer exists",
+            entity
+        ));
+    }
+    world.resource_scope(|world, registry: Mut<AppTypeRegistry>| {
+        let registry = registry.read();
+        let registration = registry
+            .get_with_type_path(&property.component_type)
+            .ok_or_else(|| {
+                format!(
+                    "component type `{}` is not registered",
+                    property.component_type
+                )
+            })?;
+        let reflect_component = registration
+            .data::<ReflectComponent>()
+            .cloned()
+            .ok_or_else(|| format!("component `{}` is not reflectable", property.component_type))?;
+        let reflected =
+            deserialize_component(&property.value_component_ron, registration, &registry)?;
+        let path = ParsedPath::parse(&property.property_path).map_err(|error| {
+            format!(
+                "invalid property path `{}`: {error}",
+                property.property_path
+            )
+        })?;
+        let source_value = path.reflect_element(reflected.as_ref()).map_err(|error| {
+            format!(
+                "override value path `{}` failed: {error}",
+                property.property_path
+            )
+        })?;
+        let mut target_component = reflect_component
+            .reflect_mut(world.entity_mut(entity))
+            .ok_or_else(|| format!("target is missing component `{}`", property.component_type))?;
+        let target_value = target_component.reflect_path_mut(&path).map_err(|error| {
+            format!(
+                "target property path `{}` failed: {error}",
+                property.property_path
+            )
+        })?;
+        target_value
+            .try_apply(source_value)
+            .map_err(|error| format!("could not apply `{}`: {error}", property.property_path))
+    })
+}
+
+fn deserialize_component(
+    text: &str,
+    registration: &bevy::reflect::TypeRegistration,
+    registry: &bevy::reflect::TypeRegistry,
+) -> Result<Box<dyn PartialReflect>, String> {
+    let mut deserializer =
+        ron::de::Deserializer::from_str(text).map_err(|error| error.to_string())?;
+    TypedReflectDeserializer::new(registration, registry)
+        .deserialize(&mut deserializer)
+        .map_err(|error| error.to_string())
+}
+
+fn apply_structural_override(
+    world: &mut World,
+    owner_root: Entity,
+    instance_chain: &[String],
+    members: &HashMap<String, Entity>,
+    structural: &PrefabStructuralOverride,
+) -> Result<(), String> {
+    match structural {
+        PrefabStructuralOverride::RemoveChild { target, .. }
+            if target.belongs_to_layer(instance_chain) =>
+        {
+            if let Some(entity) = members.get(&target.actor_id).copied() {
+                if let Ok(entity_mut) = world.get_entity_mut(entity) {
+                    entity_mut.despawn();
+                }
+            }
+        }
+        PrefabStructuralOverride::ReparentChild {
+            target,
+            new_parent,
+            local_transform_ron,
+            ..
+        } if target.belongs_to_layer(instance_chain) => {
+            let Some(entity) = members.get(&target.actor_id).copied() else {
+                return Ok(());
+            };
+            let parent = match new_parent {
+                Some(parent) if !parent.belongs_to_layer(instance_chain) => {
+                    return Err(format!(
+                        "reparent target `{}` crosses a prefab layer",
+                        parent.actor_id
+                    ));
+                }
+                Some(parent) => members
+                    .get(&parent.actor_id)
+                    .copied()
+                    .ok_or_else(|| format!("reparent target `{}` is missing", parent.actor_id))?,
+                None => owner_root,
+            };
+            if world.get_entity(parent).is_err() {
+                return Err(format!(
+                    "reparent target for `{}` no longer exists",
+                    target.actor_id
+                ));
+            }
+            if hierarchy_would_cycle(world, entity, parent) {
+                return Err(format!(
+                    "reparent override for `{}` would create a hierarchy cycle",
+                    target.actor_id
+                ));
+            }
+            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
+                entity_mut.insert(ChildOf(parent));
+                if let Some(transform) = local_transform_ron
+                    .as_deref()
+                    .and_then(|ron| ron::from_str::<Transform>(ron).ok())
+                {
+                    entity_mut.insert(transform);
+                }
+            }
+        }
+        PrefabStructuralOverride::AttachLocalChild {
+            local_actor_id,
+            parent,
+        } if parent.belongs_to_layer(instance_chain) => {
+            let Some(parent_entity) = members.get(&parent.actor_id).copied() else {
+                return Ok(());
+            };
+            let local = world
+                .query::<(Entity, &ActorId, Option<&HydratedPrefabMember>)>()
+                .iter(world)
+                .find_map(|(entity, actor_id, hydrated)| {
+                    (hydrated.is_none() && actor_id.0 == *local_actor_id && entity != owner_root)
+                        .then_some(entity)
+                });
+            if let Some(local) = local {
+                world.entity_mut(local).insert(ChildOf(parent_entity));
+            }
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+fn hierarchy_would_cycle(world: &World, entity: Entity, parent: Entity) -> bool {
+    let mut current = Some(parent);
+    let mut seen = HashSet::new();
+    while let Some(candidate) = current {
+        if candidate == entity || !seen.insert(candidate) {
+            return true;
+        }
+        current = world.get::<ChildOf>(candidate).map(ChildOf::parent);
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::asset::AssetPlugin;
+    use bevy::world_serialization::{DynamicWorld, DynamicWorldRoot, WorldSerializationPlugin};
+
+    #[test]
+    fn legacy_override_payload_decodes_with_v1_version() {
+        let instance = PrefabInstance {
+            overrides_ron: Some("(child_visibility:{\"child\":false})".to_string()),
+            ..Default::default()
+        };
+        let overrides = decode_prefab_overrides(&instance).unwrap();
+        assert_eq!(overrides.format_version, 1);
+        assert_eq!(overrides.child_visibility.get("child"), Some(&false));
+    }
+
+    #[test]
+    fn nested_actor_paths_are_distinct() {
+        let first = PrefabActorPath {
+            instance_chain: vec!["left".to_string()],
+            actor_id: "mesh".to_string(),
+        };
+        let second = PrefabActorPath {
+            instance_chain: vec!["right".to_string()],
+            actor_id: "mesh".to_string(),
+        };
+        assert_ne!(first, second);
+    }
+
+    #[test]
+    fn invalid_inner_override_payload_is_rejected_during_decode() {
+        let mut instance = PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron");
+        instance.overrides_ron = Some(
+            ron::to_string(&PrefabOverrides {
+                properties: vec![PrefabPropertyOverride {
+                    target: PrefabActorPath::direct("mesh"),
+                    component_type: std::any::type_name::<MaterialDesc>().to_string(),
+                    property_path: "roughness".to_string(),
+                    base_component_ron: "not ron".to_string(),
+                    value_component_ron: ron::to_string(&MaterialDesc::default()).unwrap(),
+                }],
+                ..default()
+            })
+            .unwrap(),
+        );
+
+        let error = decode_prefab_overrides(&instance).unwrap_err();
+        assert!(error.contains("invalid base value"), "{error}");
+    }
+
+    #[test]
+    fn shared_runtime_applies_property_override_without_editor_plugin() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin::default())
+            .add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
+            .init_asset::<Mesh>()
+            .add_plugins(WorldSerializationPlugin)
+            .insert_resource(settings::ProjectSettings::default())
+            .add_plugins(crate::SharedTypesPlugin);
+
+        let base = MaterialDesc::default();
+        let mut value = base.clone();
+        value.roughness = 0.18;
+        let overrides = PrefabOverrides {
+            properties: vec![PrefabPropertyOverride {
+                target: PrefabActorPath::direct("mesh"),
+                component_type: std::any::type_name::<MaterialDesc>().to_string(),
+                property_path: "roughness".to_string(),
+                base_component_ron: ron::to_string(&base).unwrap(),
+                value_component_ron: ron::to_string(&value).unwrap(),
+            }],
+            ..Default::default()
+        };
+
+        let mut source = World::new();
+        source.spawn((ActorId::new("mesh"), base));
+        let dynamic_world = DynamicWorld::from_world_with(
+            &source,
+            &app.world().resource::<AppTypeRegistry>().read(),
+        );
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(dynamic_world);
+        let mut instance = PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron");
+        instance.overrides_ron = encode_prefab_overrides(&overrides).unwrap();
+        app.world_mut().spawn((instance, DynamicWorldRoot(handle)));
+
+        app.update();
+
+        let world = app.world_mut();
+        let (_, material) = world
+            .query::<(&ActorId, &MaterialDesc)>()
+            .single(world)
+            .expect("shared runtime should spawn one overridden source actor");
+        assert_eq!(material.roughness, 0.18);
+    }
+
+    #[test]
+    fn runtime_applies_valid_operations_after_an_independent_operation_error() {
+        let mut app = App::new();
+        app.add_plugins(MinimalPlugins)
+            .add_plugins(AssetPlugin::default())
+            .add_plugins(bevy::pbr::MaterialPlugin::<StandardMaterial>::default())
+            .init_asset::<Mesh>()
+            .add_plugins(WorldSerializationPlugin)
+            .insert_resource(settings::ProjectSettings::default())
+            .add_plugins(crate::SharedTypesPlugin);
+
+        let transform = Transform::default();
+        let mut moved = transform;
+        moved.translation.x = 5.0;
+        let material = MaterialDesc::default();
+        let mut edited_material = material.clone();
+        edited_material.roughness = 0.09;
+        let overrides = PrefabOverrides {
+            properties: vec![
+                PrefabPropertyOverride {
+                    target: PrefabActorPath::direct("mesh"),
+                    component_type: std::any::type_name::<Transform>().to_string(),
+                    property_path: "translation".to_string(),
+                    base_component_ron: ron::to_string(&transform).unwrap(),
+                    value_component_ron: ron::to_string(&moved).unwrap(),
+                },
+                PrefabPropertyOverride {
+                    target: PrefabActorPath::direct("mesh"),
+                    component_type: std::any::type_name::<MaterialDesc>().to_string(),
+                    property_path: "roughness".to_string(),
+                    base_component_ron: ron::to_string(&material).unwrap(),
+                    value_component_ron: ron::to_string(&edited_material).unwrap(),
+                },
+            ],
+            ..default()
+        };
+
+        let mut source = World::new();
+        source.spawn((ActorId::new("mesh"), material));
+        let dynamic_world = DynamicWorld::from_world_with(
+            &source,
+            &app.world().resource::<AppTypeRegistry>().read(),
+        );
+        let handle = app
+            .world_mut()
+            .resource_mut::<Assets<DynamicWorld>>()
+            .add(dynamic_world);
+        let mut instance = PrefabInstance::new("prefab", "assets/prefabs/test.scn.ron");
+        instance.overrides_ron = encode_prefab_overrides(&overrides).unwrap();
+        app.world_mut().spawn((instance, DynamicWorldRoot(handle)));
+
+        app.update();
+
+        let world = app.world_mut();
+        let (_, material) = world
+            .query::<(&ActorId, &MaterialDesc)>()
+            .single(world)
+            .unwrap();
+        assert_eq!(material.roughness, 0.09);
+    }
+}
diff --git a/docs/README.md b/docs/README.md
index 9dffd91..89816bd 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -37,6 +37,15 @@ Immutable-style log of significant decisions. Add a new numbered ADR when changi
 | [0020](adr/0020-jackdaw-inspired-editor-roadmap.md) | Jackdaw-inspired roadmap source policy and attribution requirements |
 | [0021](adr/0021-brush-authoring-schema.md) | Brush authoring schema and hydration contract |
 | [0022](adr/0022-bevy-0-19-upgrade.md) | Bevy 0.19 / Avian 0.7 upgrade and compatibility patches |
+| [0023](adr/0023-transactional-scene-persistence-and-recovery.md) | Atomic scene writes, user-local recovery snapshots, and restore/discard policy |
+| [0024](adr/0024-versioned-editor-session-state.md) | Versioned machine-local session state and safe abnormal-shutdown resume |
+| [0025](adr/0025-project-root-is-a-startup-boundary.md) | Pre-engine project validation, activation, and sandbox contract |
+| [0026](adr/0026-stable-scene-composition-and-active-document.md) | Stable scene IDs, subscene ownership, tabs, and active-world materialization |
+| [0027](adr/0027-stable-prefab-ownership-and-variants.md) | Stable prefab ownership, nested override identity/layering, transactional source writes, variants, and local conversion |
+| [0028](adr/0028-authoritative-project-content-validation.md) | Shared editor/headless dependency manifest and project content findings |
+| [0029](adr/0029-validation-gated-build-profiles-and-packaging.md) | Shared validation-gated build profiles, runtime packaging, and metadata |
+| [0030](adr/0030-audio-authoring-and-bus-schema.md) | Serializable audio sources/listeners, stable clip references, and project bus graph |
+| [0031](adr/0031-animation-authoring-runtime-contract.md) | glTF animation artifacts, stable controller states, runtime hydration, and exact-signature retargeting |
 
 ## Editor framework
 
@@ -45,10 +54,19 @@ Immutable-style log of significant decisions. Add a new numbered ADR when changi
 | [editor/release-notes.md](editor/release-notes.md) | Editor framework 1.0 baseline |
 | [editor/evaluations/](editor/evaluations/) | Horizon gate sign-offs (R1–R6) |
 | [editor/architecture.md](editor/architecture.md) | Viewport / PIE / settings data flow |
+| [editor/visual-language.md](editor/visual-language.md) | Editor chrome, viewport, selection, gizmo, and visualizer language |
 | [editor/roadmap.md](editor/roadmap.md) | Phased editor roadmap and status |
 | [editor/brp.md](editor/brp.md) | BRP automation and authoring-only policy |
 | [editor/debt-audit.md](editor/debt-audit.md) | Zero-debt phase gates |
 | [editor/brushes.md](editor/brushes.md) | Brush authoring schema, hydration behavior, and MVP limits |
+| [editor/operator-regression-testing.md](editor/operator-regression-testing.md) | Reusable modal-tool and operator invariant harness |
+| [editor/session-recovery.md](editor/session-recovery.md) | Clean restart, abnormal shutdown, session schema, and privacy boundary |
+| [editor/project-launcher.md](editor/project-launcher.md) | Project manifests, explicit startup roots, recents, and sandbox scaffolding |
+| [editor/build-and-package.md](editor/build-and-package.md) | Editor/headless package profiles, output, exclusions, and metadata |
+| [editor/multi-scene-composition.md](editor/multi-scene-composition.md) | Independent scene tabs, composition ownership, validation, and recovery |
+| [editor/prefab-authoring.md](editor/prefab-authoring.md) | Linked instances, scoped overrides/source Apply, conflicts, variants, unpacking, and local conversion |
+| [editor/audio-authoring.md](editor/audio-authoring.md) | Audio clips, source/listener authoring, audition, buses, runtime parity, and validation |
+| [editor/animation-authoring.md](editor/animation-authoring.md) | glTF rigs/clips, controller states, preview, runtime requests, stable moves, and validation |
 
 ## Working plans (not canonical long-term)
 
@@ -63,6 +81,8 @@ Detailed milestone and feature plans live in [`.cursor/plans/`](../.cursor/plans
 | `static_mesh_asset_refactor_*.plan.md` | Static mesh renderer, normalized model artifacts, inspector redesign |
 | `component_system_refactor_*.plan.md` | Component registry, imported asset refs, collider split, material overrides |
 | `jackdaw_feature_roadmap_*.plan.md` | Jackdaw-inspired production roadmap; tracked in Gitea as `BS-JD-*` issues |
+| `blacksite_production_readiness_*.plan.md` | M6-M7 reliability, content production, shipping, and acceptance gates |
+| `animation_authoring_*.plan.md` | M7 glTF skeletal animation import, preview, controller, and runtime acceptance |
 
 ## Crate responsibilities (quick reference)
 
diff --git a/docs/adr/0005-prefab-instance-and-asset-registry.md b/docs/adr/0005-prefab-instance-and-asset-registry.md
index f11083c..3bc8622 100644
--- a/docs/adr/0005-prefab-instance-and-asset-registry.md
+++ b/docs/adr/0005-prefab-instance-and-asset-registry.md
@@ -2,7 +2,8 @@
 
 ## Status
 
-Accepted
+Accepted for asset identity; structural ownership superseded by
+[ADR 0027](0027-stable-prefab-ownership-and-variants.md)
 
 ## Context
 
@@ -11,11 +12,23 @@ Editor prefab placement and content pipeline work (H1/H2) require stable asset i
 ## Decision
 
 - Persist stable `AssetId` (UUID) per `assets/` path in `assets/.index/registry.ron`.
+- Scene-instance `ModelRef` stores the registry UUID plus a cached source path. Hydration resolves
+  the UUID-keyed generated manifest first, allowing uniquely identified model moves to retain scene
+  and animation references.
+- Catalog refresh reconciles a missing model record to one new path only when its generated content
+  hash has exactly one match. Copies and ambiguous matches receive new IDs.
 - Introduce `PrefabInstance { asset_id, source_path, overrides_ron }` on placed prefab roots alongside hydration via `PrefabRef`.
 - Scene save includes `PrefabInstance` and gameplay marker components from `shared`.
+- The initial structural boundary treated instance contents as read-only and required Unpack before
+  authored structural edits. ADR 0027 replaces that boundary with explicit generated-member
+  ownership while retaining this ADR's asset and instance identity.
 
 ## Consequences
 
 - Prefab paths can be resolved through the registry for dependency tracking.
 - Override apply/revert (H2) builds on `overrides_ron` without changing the instance component shape.
+- Stable child identity, authored local children, nested instances, variants, and recursive graph
+  validation are defined by ADR 0027.
 - Registry must be version-controlled with the project.
+- Legacy path-only `ModelRef` values remain readable but require reassignment before they gain stable
+  move resolution.
diff --git a/docs/adr/0006-scene-schema-versioning.md b/docs/adr/0006-scene-schema-versioning.md
index 18b5262..2a02158 100644
--- a/docs/adr/0006-scene-schema-versioning.md
+++ b/docs/adr/0006-scene-schema-versioning.md
@@ -13,10 +13,16 @@ Levels under `assets/levels/` need forward-compatible migrations as authoring co
 - Track `schema_version` in scene files (wrapper or sidecar during transition).
 - Provide `scene_schema` module with `migrate_scene_text` and `validate_level_file`.
 - Route editor save/load through `scene::document::SceneDocument`, an internal Bevy-free seam that preserves DynamicScene RON while exposing stable actor/component document identities and patch operations for tools.
-- CI / `xtask validate-levels` loads all committed levels and fails on unknown versions.
+- CI / `xtask validate-levels` loads all committed levels and recursively validates every committed
+  prefab graph, failing on unknown versions or invalid links/override payloads.
+- Keep `scene` Bevy-free. A narrow loader adapter in `game` validates and migrates `.scn.ron`
+  assets through `scene`, strips the schema envelope in memory, and then invokes Bevy's
+  `WorldDeserializer`. The packaged game and editor therefore hydrate the same versioned prefab
+  files that authoring and CI validate.
 
 ## Consequences
 
 - Breaking component changes require a migration step and version bump.
-- Editor save may wrap scenes with schema header in a follow-up change.
+- Editor saves wrap levels and prefabs with the schema header; the runtime adapter removes only the
+  envelope before Bevy deserialization.
 - The current storage format remains DynamicScene RON; `SceneDocument` is not a BSN/JSN migration.
diff --git a/docs/adr/0023-transactional-scene-persistence-and-recovery.md b/docs/adr/0023-transactional-scene-persistence-and-recovery.md
new file mode 100644
index 0000000..6cc689f
--- /dev/null
+++ b/docs/adr/0023-transactional-scene-persistence-and-recovery.md
@@ -0,0 +1,48 @@
+# ADR 0023: Transactional Scene Persistence And Recovery
+
+## Status
+
+Accepted
+
+## Context
+
+Blacksite previously wrote scene RON directly to the authored path. An interruption during that
+write could corrupt the last good scene. The save serializer also strips hydrated runtime state
+before extraction and only rebuilt it after a successful write, so serialization or filesystem
+failure could leave the live editor world partially stripped.
+
+Daily production additionally needs a recovery path for dirty scenes that does not modify project
+assets, mark a scene clean, enter source control, or silently replace authored work.
+
+## Decision
+
+- Manual scene, prefab, and selection writes use a temporary file in the destination directory,
+  flush and sync its bytes, atomically rename it over the destination, and sync the parent
+  directory where the platform permits.
+- Authored document serialization is separate from persistence. Hydrated state is always rebuilt
+  after serialization attempts, including validation and serialization failures.
+- Dirty saved scenes produce recovery snapshots every 120 seconds by default. The interval has a
+  15-second safety floor and the newest five generations are retained by default.
+- Recovery data lives under `$XDG_STATE_HOME/blacksite-editor/recovery` or
+  `~/.local/state/blacksite-editor/recovery`. Stable hashes of project root and scene path keep
+  recovery files outside the project without leaking path names into directory names.
+- A recovery snapshot never clears the dirty flag and uses the same authoring-only serialization
+  contract as manual save.
+- On scene load, a newer recovery snapshot is surfaced in the status strip and File menu. The
+  editor never restores it automatically. Restore loads the snapshot into the original scene
+  context and leaves the scene dirty; the snapshot remains available until manual Save commits it
+  or Discard removes that scene's recovery generations. Save Recovery Copy As writes the snapshot
+  to a separate transactional scene file without changing the active scene or recovery lifecycle.
+- A successful manual save retires recovery generations for that scene.
+
+## Consequences
+
+- Interrupted manual writes retain the previous complete destination on filesystems with atomic
+  same-directory rename semantics.
+- Recovery is machine-local and does not pollute builds or source control.
+- Autosave still performs authored serialization and hydration rebuild work. Performance
+  instrumentation and background snapshotting remain follow-up work under the production roadmap.
+- Unsaved new scenes do not yet have a stable recovery identity; they require a later session-ID
+  recovery extension.
+- The initial controls use user preference fields and documented defaults; a dedicated Preferences
+  panel can expose them later without changing the storage contract.
diff --git a/docs/adr/0024-versioned-editor-session-state.md b/docs/adr/0024-versioned-editor-session-state.md
new file mode 100644
index 0000000..a5642bf
--- /dev/null
+++ b/docs/adr/0024-versioned-editor-session-state.md
@@ -0,0 +1,40 @@
+# ADR 0024: Versioned Editor Session State
+
+## Status
+
+Accepted
+
+## Context
+
+User preferences already preserve dock layout and hierarchy options, while scene recovery preserves
+dirty authored data. Neither establishes whether the editor exited cleanly, and several productive
+session details such as the active scene, panel visibility, and viewport bookmarks were memory-only.
+Restoring those details from an abnormal session must not revive a modal tool, dirty preview, or
+untrusted serialized ECS state.
+
+## Decision
+
+- Store a separate, versioned `session.ron` under `$XDG_STATE_HOME/blacksite-editor` or
+  `~/.local/state/blacksite-editor`. User preferences remain in the user config directory and scene
+  recovery remains a separate generation store.
+- Session schema v1 allowlists metadata only: project root, active scene path, saved dock-layout
+  text, hierarchy expansion paths, non-destructive panel visibility, and finite camera bookmark
+  transforms.
+- Write the session transactionally. Startup immediately writes `clean_shutdown: false`; normal
+  `AppExit` writes the final document with `clean_shutdown: true`.
+- A clean prior session may restore its active scene and non-destructive UI state automatically.
+  An abnormal prior session starts from the normal safe scene and requires explicit confirmation
+  before opening the prior scene.
+- Never serialize scene contents, modal operator state, unsaved preview geometry, environment
+  variables, credentials, or access tokens into session state.
+- Missing schema version migrates to v1. Newer unknown schemas are rejected rather than guessed.
+
+## Consequences
+
+- Session restore is independent of project source control and cannot modify project files merely
+  by starting the editor.
+- A process killed before `AppExit` leaves an actionable abnormal marker on the next launch.
+- Dock/hierarchy preference persistence remains backward-compatible, while session state can evolve
+  through explicit schema migrations.
+- Diagnostics bundles may report allowlisted session metadata, but must maintain the same privacy
+  boundary.
diff --git a/docs/adr/0025-project-root-is-a-startup-boundary.md b/docs/adr/0025-project-root-is-a-startup-boundary.md
new file mode 100644
index 0000000..a327b4f
--- /dev/null
+++ b/docs/adr/0025-project-root-is-a-startup-boundary.md
@@ -0,0 +1,51 @@
+# ADR 0025: Project Root Is a Startup Boundary
+
+## Status
+
+Accepted
+
+## Context
+
+Bevy configures `AssetPlugin.file_path` before editor plugins and project settings initialize. The
+asset catalog, scene loader, import pipeline, session state, and runtime game systems must all agree
+on one project root. Changing only editor metadata in a running process leaves `AssetServer` and
+already-created handles attached to the old project, which can silently read or write the wrong
+content.
+
+Projects also need stable identity and enough template metadata for a launcher to distinguish a
+game workspace from a disposable sandbox without inspecting arbitrary project contents.
+
+## Decision
+
+- Select and validate the project root before constructing the Bevy `App`. `--project <root>`, the
+  graphical launcher, and recent-project resume all feed the same pre-engine activation function.
+- Do not implement in-process project switching. **Switch Project** exits or relaunches through the
+  launcher so the next process creates `AssetPlugin`, settings, catalog, and session state from one
+  root.
+- Extend `assets/project.ron` with backward-compatible `project_id`, `project_kind`,
+  `template_version`, and capability tags. Legacy manifests receive safe defaults; new projects
+  receive a UUID.
+- A valid project has a parseable manifest, a project-relative default level that cannot escape the
+  root, and a default level that passes the shared scene validator.
+- The standalone `GamePlugin` materializes that `default_level` through the schema-aware Bevy
+  `DynamicWorld` loader. Embedded editor startup explicitly defers this step so `SceneIo` remains
+  the sole owner of the active authored document, tabs, composition, and recovery state.
+- Sandbox scaffolding writes only to a missing or empty destination. It creates the standard asset
+  directories, a schema-current empty level, and a manifest using transactional writes.
+- Recent-project presentation filters missing, invalid, and duplicate roots before showing them.
+- On Linux, launcher-to-editor and editor-to-launcher handoffs use independent transient user
+  services with an explicit working directory and a bounded display/session environment allowlist.
+  Closing either source process therefore cannot tear down the process it launched.
+
+## Consequences
+
+- Project activation cannot leave the editor half-connected to two asset roots.
+- Packaged and workspace game binaries start in the validated authored default level instead of the
+  procedural editor fallback arena; the editor cannot race a second runtime-owned scene load.
+- Switching projects requires a process boundary, but startup remains deterministic and testable.
+- Project scaffolding is intentionally conservative and cannot merge into a directory containing
+  user data.
+- Template migrations and capability negotiation can evolve independently of the project-settings
+  file format version.
+- The service-manager handoff is Linux-specific; other platforms use the local process-spawn
+  fallback until native packaging provides a stronger lifecycle boundary.
diff --git a/docs/adr/0026-stable-scene-composition-and-active-document.md b/docs/adr/0026-stable-scene-composition-and-active-document.md
new file mode 100644
index 0000000..44904d4
--- /dev/null
+++ b/docs/adr/0026-stable-scene-composition-and-active-document.md
@@ -0,0 +1,47 @@
+# ADR 0026: Stable Scene Composition And Active Document
+
+## Status
+
+Accepted
+
+## Context
+
+One monolithic dynamic scene does not scale to daily content production. Multiple authors and
+disciplines need geometry, lighting, gameplay, and set dressing to remain separable, but Bevy
+`Entity` identifiers are allocated at runtime and cannot identify actors or ownership across files.
+The editor also materializes one authored document into the live ECS world, where hydration,
+selection, history, PIE, and rendering operate.
+
+## Decision
+
+- Persist one reflected `SceneComposition` resource in each dynamic scene. It owns a stable
+  `scene_id` and project-relative `SubsceneReference` entries with stable reference IDs plus loaded
+  and locked flags.
+- Reject absolute/escaping paths, empty or duplicate reference IDs, missing targets, duplicate
+  scene IDs, and cyclic graphs through the same `scene` crate validator used by editor load,
+  project inspection, and `cargo validate-levels`.
+- Keep one scene tab materialized in the ECS world. Inactive tabs retain normalized authored RON,
+  path, dirty state, and recovery location in memory. Switching serializes the outgoing authored
+  roots and hydrates the incoming snapshot.
+- Tag hydrated subscene actors with runtime-only `ComposedSceneMember` ownership. They participate
+  in the active composition and PIE but are excluded from the owner scene's save and recovery
+  payload.
+- Treat an unloaded reference as absent from the world. Loaded references inherit their authored
+  visibility; locked references enter the hierarchy's existing read-only lock path. Nested locks
+  propagate downward.
+- Composition add/remove/load/lock changes are ordinary undoable history commands. Because existing
+  entity-edit history stores runtime entity IDs, activating another tab clears that tab's history
+  instead of retaining commands that could target rematerialized entities incorrectly.
+
+## Consequences
+
+- Cross-scene identity is stable and reviewable without leaking runtime entity IDs into files.
+- PIE, viewport rendering, and build validation see the same active materialized composition.
+- Saved dirty tabs, including inactive ones, receive independent bounded recovery generations.
+- Legacy scenes load without a composition resource using a deterministic path-derived identity;
+  their next save promotes that identity into the scene resource.
+- The open tab set is session-local; safe restart resumes the last active authored scene. Unsaved
+  untitled tabs remain outside automatic recovery until a future session schema can restore them
+  without guessing a destination.
+- Preserving entity-edit undo stacks across tab materialization requires stable-ID history commands
+  and is future work; clearing them is explicit and safe.
diff --git a/docs/adr/0027-stable-prefab-ownership-and-variants.md b/docs/adr/0027-stable-prefab-ownership-and-variants.md
new file mode 100644
index 0000000..b53dd1c
--- /dev/null
+++ b/docs/adr/0027-stable-prefab-ownership-and-variants.md
@@ -0,0 +1,89 @@
+# ADR 0027: Stable Prefab Ownership, Overrides, And Variants
+
+## Status
+
+Accepted
+
+## Context
+
+ADR 0005 established stable asset-registry identity and linked `PrefabInstance` roots, but the
+first structural boundary treated every descendant of an instance as generated source content.
+That prevented an authored scene or prefab from adding local children, nesting another linked
+instance, or expressing a variant without flattening the source prefab.
+
+Bevy allocates `Entity` identifiers at runtime, and display names can change. Neither is a durable
+key for an override, especially when multiple nested prefab layers contain the same source
+`ActorId`. Overrides must also produce the same result in a packaged game that does not include the
+editor. Finally, publishing an override to a source file crosses the in-memory undo boundary and
+must not overwrite unrelated external edits.
+
+## Decision
+
+- Keep `PrefabInstance { asset_id, source_path, overrides_ron }` as the authored, serialized link.
+  Its source path remains project-relative and under `assets/`.
+- Tag entities spawned from that link with runtime-only `HydratedPrefabMember { instance_root }`.
+  Tagged source members are excluded from scene, recovery, and prefab serialization. The linked
+  root, authored local descendants, and nested `PrefabInstance` actors remain editable and
+  serializable.
+- Parse `PrefabInstance` components through `SceneDocument` and validate the dependency graph
+  recursively. Reject empty asset IDs, unsafe or non-`.scn.ron` paths, missing sources, dependency
+  cycles, authored actors without `ActorId`, and duplicate `ActorId` values within one document.
+  Editor load, prefab save, project inspection, and level validation use this structured path.
+- Store overrides in the versioned, shared `PrefabOverrides` contract. A `PrefabActorPath` combines
+  an `instance_chain` of nested link-anchor `ActorId` values with the target actor's `ActorId`, so
+  repeated IDs in different nested documents remain unambiguous. Runtime override application
+  lives in `shared` hydration rather than the editor.
+- Property overrides carry a reflected component type, property path, base component value, and
+  replacement component value.
+- Component overrides add, replace, or remove a reflected component and retain its base value.
+- Structural overrides remove or reparent a source actor. The schema reserves local-child
+  attachment, but the editor does not expose attachment directly to a generated member until its
+  reload and ownership lifecycle is safe.
+- Retain the v1 root transform, material, and child-visibility fields for wire compatibility. New
+  authoring uses stable property/component/structural operations; legacy child visibility remains
+  keyed by `ActorId`, with name keys read only as a compatibility fallback.
+- Resolve a composed result in increasing specificity: source document, each nested link's override
+  layer, the containing variant document and its authored local structure, then the placed
+  instance's overrides. A containing layer may target a nested source actor through its stable
+  `instance_chain` without flattening that source.
+- Distinguish **instance override** from **Apply to source**. Editing a linked member records an
+  undoable operation in the containing `PrefabInstance`. Applying a direct target to source patches
+  that source document. Applying a nested target transfers the operation into the immediate nested
+  link stored by the containing source; it does not skip the composition layer and mutate a leaf
+  prefab unexpectedly.
+- Validate the complete graph and write source changes atomically. The source-apply history command
+  stores the exact source bytes before and after the write plus the instance state. Undo and redo
+  proceed only when the current file exactly matches the expected side of that command; an external
+  change blocks the history operation instead of being overwritten.
+- Record a transitive deterministic source-graph revision and the base values needed for three-way
+  conflict checks. Health distinguishes loading, ready, untracked, changed-base, semantic/stale
+  conflict, broken-source, and malformed-override states. Conflict recovery can rebase while keeping
+  overrides, take the current source for conflicting operations, remove legacy stale targets,
+  retry a repaired source, or relink to another validated prefab.
+- Make **Unpack Layer** an undoable outer-layer conversion: remove the selected instance link and
+  retain its hydrated members as authored local actors, while preserving nested `PrefabInstance`
+  links. Make **Convert to Local** the explicit recursive conversion: remove all nested links in the
+  selected instance result, assign fresh local `ActorId` values, and store snapshots so redo does not
+  depend on the source files.
+- Define a variant as an ordinary prefab document whose selected root is itself a linked
+  `PrefabInstance`. Saving the selection serializes that link, its override layer, and authored local
+  descendants/nested instances while excluding hydrated source members. No separate variant asset
+  type is introduced.
+
+## Consequences
+
+- Nested prefab graphs and variants preserve their source links instead of duplicating generated
+  content into every owner file. The same shared override data is applied by editor and game
+  hydration.
+- Renaming a source actor does not break current overrides while its `ActorId` and nested anchor
+  chain remain stable. Moving an actor between documents or replacing an anchor is an identity
+  change and can surface a recoverable conflict.
+- Instance-local edits and Revert operations remain ordinary editor history. **Apply to source** is an
+  explicit asset mutation with stricter exact-file undo/redo preconditions.
+- Generated members may be removed or reparented inside the same prefab layer through structural
+  overrides. Cross-layer parenting, generated sibling-order overrides, and direct authored-local
+  attachment to generated members remain intentionally blocked until their persistence semantics
+  are defined.
+- **Unpack Layer** preserves reusable nested links; **Convert to Local** intentionally severs all
+  links and creates a source-independent authored snapshot. The destructive scope is visible in the
+  command name rather than inferred.
diff --git a/docs/adr/0028-authoritative-project-content-validation.md b/docs/adr/0028-authoritative-project-content-validation.md
new file mode 100644
index 0000000..6229ab3
--- /dev/null
+++ b/docs/adr/0028-authoritative-project-content-validation.md
@@ -0,0 +1,44 @@
+# ADR 0028: Authoritative project content validation
+
+## Status
+
+Accepted
+
+## Context
+
+Scene, prefab, and imported-asset checks were distributed across editor loading, hydration, and the
+`validate-levels` task. A project could therefore pass headless scene validation while still
+containing a missing model, texture, material, shader, generated mesh manifest, post effect, or
+rendering profile reference. Editor-only validation would also risk disagreeing with CI and release
+tooling.
+
+## Decision
+
+The Bevy-free `scene` crate owns `validate_project` and the structured
+`ProjectValidationReport`. The report contains a deterministic dependency manifest and findings
+with severity, stable code, source document, owning `ActorId` where available, referenced path,
+message, and repair action.
+
+Both the editor Diagnostics window and the `cargo validate-levels` headless command call this same
+entry point. The command supports `--project <path>` and `--json`; the editor can select the live
+owning actor for an attributed finding. Blocking errors produce a nonzero headless exit status.
+
+Project validation covers the project manifest and asset roots, registry IDs/sources/dependencies,
+generated static mesh manifests, material and shader documents, post effects, scene and prefab
+graphs, authored model/material/texture/brush/collider references, rendering profiles, and
+unhydrated Git LFS pointer files. The validator owns the runtime-packageability predicate consumed by
+the packager: editor/hidden trees, source-authoring formats, symlinks, and unreadable traversal are
+blocking rather than being accepted and later omitted. The project default must be a regular
+`.scn.ron` file under `assets/levels/`, which guarantees the full document dependency pass audits the
+startup entrypoint. Unknown newer scene schemas are rejected rather than down-stamped. Platform
+requirements are explicit findings; for example, Solari projects record the required forward-path
+fallback QA when ray tracing is unavailable.
+
+## Consequences
+
+- Headless and editor validation share result semantics and finding ownership.
+- Missing references are visible before Bevy hydration attempts to load them.
+- Release packaging invokes this report before and after compilation and refuses blocking errors;
+  Gitea #44 acceptance verifies the shared gate against real development output.
+- Asset formats added later must register their dependencies with this validator and extend the
+  valid, missing, cyclic, and incompatible project-fixture matrix.
diff --git a/docs/adr/0029-validation-gated-build-profiles-and-packaging.md b/docs/adr/0029-validation-gated-build-profiles-and-packaging.md
new file mode 100644
index 0000000..ccc731f
--- /dev/null
+++ b/docs/adr/0029-validation-gated-build-profiles-and-packaging.md
@@ -0,0 +1,66 @@
+# ADR 0029: Validation-gated build profiles and packaging
+
+## Status
+
+Accepted
+
+## Context
+
+Blacksite builds previously required users to know Cargo commands and manually assemble assets. That
+made it easy to ship broken references, editor caches, recovery data, or an executable without the
+settings and content that produced it. Ordinary debug binaries are also too large for practical
+distribution, while release LTO is too expensive for every development package.
+
+## Decision
+
+Projects define versioned RON profiles under `assets/build_profiles/`. A profile selects the Cargo
+package profile, optional target triple and feature set, rendering tier, default scene, and a safe
+project-relative output directory. Development and QA exports use dedicated optimized non-LTO Cargo
+profiles; QA retains line tables, while release exports retain thin LTO and strip symbols. The
+development rendering tier forces the portable Forward GI path in the packaged project settings;
+representative and shipping tiers preserve the authored rendering policy. Windows MSVC QA packages
+include Cargo's PDB sidecar and record it in the content manifest.
+
+`cargo package-project` is the authoritative build/package entry point for editor and CI. It runs
+`scene::validate_project` before compiling, builds `game`, reads the executable path from Cargo's
+JSON artifact stream, then validates again against a BLAKE3 snapshot of the runtime inputs. A profile
+default scene must be a regular `.scn.ron` file under the fully audited `assets/levels/` tree and pass
+schema plus composition validation. The selected default scene and rendering tier are applied to the
+packaged `project.ron`. Metadata records profile, target, features, rendering tier, default scene,
+exact engine/project commit and
+dirty state, Rust/Cargo versions, and a sorted BLAKE3 content manifest. Features that require the
+development or hot-reload dynamic libraries are rejected because those libraries are not shipping
+artifacts.
+
+Runtime packaging excludes the editor asset registry, trash, thumbnails, build profiles, recovery
+and autosave data, temporary/backup files, and source-authoring formats. Traversal errors and runtime
+asset symlinks are blocking instead of silently omitting content. Output is restricted to a dedicated
+non-symlinked `dist/<name>/` tree. A non-empty existing directory must carry recognized package
+metadata before it can be seeded or pruned, preventing a profile typo from replacing project source
+or an unrelated user directory.
+
+Assembly happens in a unique sibling staging directory copied from the previous package. Staging has
+no shared file inodes with the published output, and its complete content is rehashed before
+promotion, so a failed build or external output edit cannot mutate the candidate package. An
+OS-backed per-output lock prevents concurrent publication on Unix and Windows. Versioned
+ownership records authenticate lock/staging cleanup; an interrupted run removes only owned partial
+staging and restores a strictly validated prior backup before retrying. Only a complete,
+unchanged-input package is promoted; stale files and obsolete directory shapes are pruned in staging.
+The editor Build panel invokes the same engine-workspace Cargo alias for the active external project,
+streams stdout/stderr, owns and cancels its worker/process tree, and exposes Build, Build and Run,
+and Reveal Output. Dirty scene tabs block a build. Cross-target packages are produced but Build and
+Run refuses to execute a binary for a different host operating system or CPU architecture.
+
+## Consequences
+
+- Editor and headless builds have identical validation, profile, inclusion, and metadata semantics.
+- Blocking content errors fail before compiler or output work and are checked again after a long
+  compile. Concurrent asset mutation aborts staging without replacing the previous package.
+- The first build of a package profile compiles optimized intermediates; later unchanged builds reuse
+  Cargo intermediates and avoid rewriting byte-identical files after seeding the staged copy.
+- Cross-compilation still requires the selected Rust target and platform linker/toolchain to be
+  installed; missing tools are reported by Cargo in the Build panel. The native layout currently
+  accepts desktop Linux and Windows targets only; web, mobile, and platform-bundle formats require
+  dedicated future packagers rather than being mislabeled as ready native packages.
+- `--skip-build` requires an explicit matching `game` artifact, avoiding guesses about Cargo target
+  directories or configured default targets.
diff --git a/docs/adr/0030-audio-authoring-and-bus-schema.md b/docs/adr/0030-audio-authoring-and-bus-schema.md
new file mode 100644
index 0000000..e0e3694
--- /dev/null
+++ b/docs/adr/0030-audio-authoring-and-bus-schema.md
@@ -0,0 +1,42 @@
+# ADR 0030: Audio Authoring And Bus Schema
+
+## Status
+
+Accepted
+
+## Context
+
+Audio sources and listeners must round-trip through authored scenes without serializing Bevy's
+runtime playback handles or sink state. Source routing must also survive bus display-name changes,
+project reloads, PIE, and packaging. Bevy provides playback and spatial-listener primitives, but it
+does not define Blacksite's persistent authoring schema or project bus graph.
+
+## Decision
+
+`shared` owns reflected, serializable `AudioSourceDesc`, `AudioListenerDesc`,
+`AudioAttenuationDesc`, and `AudioRolloff` types. Dedicated authored audio actors use the
+`AudioSource` and `AudioListener` actor kinds. Runtime playback, sink, and listener components are
+derived state and are never scene source of truth.
+
+An authored clip uses `EditorAssetRef`. Its registry identity remains authoritative, its imported
+sub-asset ID is `audio:source`, and its cached source path supports runtime hydration and package
+validation. Source bus references store stable bus IDs rather than display labels.
+
+`settings` owns `AudioSettings` and its bus graph. Every project contains stable `master`, `music`,
+and `sfx` IDs; Music and SFX route to Master by default. Additional buses are allowed when their
+lowercase stable IDs are unique and their parent chain terminates at Master. Validation rejects
+missing required buses, invalid gain values, missing parents, unknown references, and cycles.
+
+The `ProjectSettings.audio` field uses a serde default so older manifests load with the standard
+bus graph. New project and sandbox manifests include the audio capability and `assets/audio` root.
+
+## Consequences
+
+- Renaming a bus label is safe; changing a bus ID is a routing migration.
+- Editor audition and game playback share one authored contract while retaining independent
+  transient runtime state.
+- Continuous spatial blend and attenuation behavior belong to the runtime adapter; the schema does
+  not claim those controls map one-to-one to native Bevy components.
+- DSP graphs, sends, reverb zones, streaming banks, and middleware integration remain future work.
+- Gitea issue #47 passed automated, headless, live editor/PIE, and packaged-runtime acceptance; this
+  contract is the M7 audio baseline.
diff --git a/docs/adr/0031-animation-authoring-runtime-contract.md b/docs/adr/0031-animation-authoring-runtime-contract.md
new file mode 100644
index 0000000..6f8d85e
--- /dev/null
+++ b/docs/adr/0031-animation-authoring-runtime-contract.md
@@ -0,0 +1,87 @@
+# ADR 0031: Animation Authoring And Runtime Contract
+
+## Status
+
+Accepted
+
+## Context
+
+Blacksite currently records animation and skin counts while importing glTF and FBX models, but the
+authored scene contract contains only a path-based `ModelRef`. Scene-instance hydration loads a
+model world without selecting or driving its clips, and the editor has no stable clip references,
+controller inspector, preview, or compatibility validation.
+
+Bevy 0.19 already exposes complete glTF scene, skin, `AnimationClip`, `AnimationGraph`, and
+`AnimationPlayer` primitives. The patched FBX loader does not: it parses some skin metadata but does
+not build the source node hierarchy, attach Bevy skinned-mesh bindings, or convert animation curves
+into clips. Treating its metadata counts as playback support would create scenes that appear valid
+but remain static at runtime.
+
+Animation authoring also needs a boundary between persistent intent and transient Bevy player state.
+Clip references must survive project asset moves, preview must agree with PIE, and a game extension
+must be able to request authored states without depending on editor types.
+
+## Decision
+
+Animation authoring v1 supports glTF 2.0 sources (`.gltf` and `.glb`) through Bevy's native loader.
+FBX remains a supported static-model source only. Import or validation of an FBX containing
+animation stacks or skin deformers must produce an actionable blocking diagnostic until the loader
+can construct hierarchy, Bevy skinned meshes, and animation clips.
+
+Each animated model has a versioned generated manifest under `assets/animations/generated/`, keyed
+by the model's stable asset-registry UUID. The manifest records the source path and fingerprint,
+skeletons and their exact signatures, stable clip sub-asset IDs, clip label/index/duration, target
+skeleton signature, normalized event markers, and import diagnostics. Registry UUID plus sub-asset
+ID is authoritative; cached `ModelRef` and `EditorAssetRef` source paths are only runtime-resolution
+and repair hints. UUID-keyed generated manifests provide the current source path after a uniquely
+reconciled move.
+
+`shared` owns reflected, serializable `AnimationControllerDesc` and its named state/event value
+types. A controller sits beside the model scene reference and uses `EditorAssetRef` for skeleton and
+clip references. It contains one layer of named states, one default state, a default crossfade
+duration, and per-state playback range, loop, and speed. State IDs are stable authored identifiers;
+display labels are not runtime keys.
+
+Retargeting v1 requires an exact skeleton-signature match. The signature is a deterministic hash of
+ordered joint target paths and bind-pose structure. For glTF, each path is hashed as a
+length-prefixed vector of the exact UTF-8 node-name bytes Bevy 0.19 uses, including whitespace and
+path separators; unnamed nodes use Bevy's `GltfNode{index}` fallback. The readable normalized paths
+stored in the manifest are display metadata and never compatibility keys. Blacksite does not infer
+humanoid roles, rename joints, or perform proportional remapping in this version. This exact node
+identity contract is animation-manifest schema v2; v1 artifacts must be reimported.
+
+The runtime adapter waits for the model `WorldAssetRoot` instance to report readiness, finds its
+animation player, and derives Bevy graph/player state from the controller. Generated instance,
+graph, player, transition, and playback bookkeeping is transient and excluded from authored scene
+serialization. Rehydration owns a dedicated generated instance root and must not despawn authored
+children attached to the actor.
+
+`game` exposes a small request API that changes an animated actor to a named state and applies the
+authored/default crossfade. Invalid state requests are rejected without disturbing the active
+state. The editor's preview and scrub controls use the same runtime adapter; starting, stopping, or
+scrubbing a preview never changes the authored descriptor, history, or scene dirty state.
+
+Interactive diagnostics, headless validation, and packaging resolve the same manifest and enforce
+source availability, stable reference resolution, supported formats, valid playback ranges/events,
+and exact skeleton compatibility.
+
+Animation v1 supports one top-level animated hierarchy per glTF asset. Import scans every animation
+channel using the same top-level roots Bevy uses for `AnimationPlayer` placement. A source requiring
+multiple players is marked runtime-unsupported with a blocking repair diagnostic; artists must split
+the rigs into separate assets or export all clips beneath one common root.
+
+## Consequences
+
+- glTF/GLB is the only animation interchange format promised by v1; artists must convert animated
+  FBX sources before import.
+- Stable registry and sub-asset identities allow source moves without rewriting every controller,
+  while ambiguous or removed clips become explicit validation failures.
+- One-layer named states provide a deterministic gameplay integration point without committing the
+  editor to a visual graph format prematurely.
+- Exact-signature retargeting is intentionally restrictive but cannot silently deform the wrong rig.
+- Rejecting multiple animation roots prevents the runtime adapter from selecting an arbitrary first
+  player and driving only part of a source.
+- A future visual graph, blend trees, root motion, IK, advanced retargeting, or animated FBX support
+  must extend or supersede this contract explicitly rather than leaking runtime Bevy components into
+  authored scenes.
+- Implementation and production acceptance are tracked in Gitea issue #46.
diff --git a/docs/editor/README.md b/docs/editor/README.md
index b6f4763..45148ad 100644
--- a/docs/editor/README.md
+++ b/docs/editor/README.md
@@ -12,6 +12,14 @@ Docs for the in-process egui editor (`crates/editor/`). Update this index when a
 | [debt-audit.md](debt-audit.md) | Zero-debt phase gates and remaining items |
 | [rendering.md](rendering.md) | GI modes, post-process volumes, presets, post FX assets |
 | [brushes.md](brushes.md) | Brush authoring schema, hydration behavior, and MVP limits |
+| [operator-regression-testing.md](operator-regression-testing.md) | Shared modal-tool commit/cancel/dirty/helper/undo invariants |
+| [session-recovery.md](session-recovery.md) | Versioned restart state, clean/crash behavior, and privacy boundary |
+| [project-launcher.md](project-launcher.md) | Pre-engine project selection, manifest identity, recents, and sandbox contract |
+| [build-and-package.md](build-and-package.md) | Non-blocking editor builds, headless profiles, runtime output, and metadata |
+| [multi-scene-composition.md](multi-scene-composition.md) | Scene tabs, stable subscene references, ownership, validation, and recovery |
+| [prefab-authoring.md](prefab-authoring.md) | Stable nested overrides, source Apply/conflicts, variants, unpacking, and local conversion |
+| [audio-authoring.md](audio-authoring.md) | Audio clip placement, source/listener controls, audition, buses, runtime parity, and validation |
+| [animation-authoring.md](animation-authoring.md) | glTF rig/clip import, stable controller states, preview, runtime API, and validation |
 
 ## Subsystems (code → doc)
 
@@ -19,19 +27,26 @@ Docs for the in-process egui editor (`crates/editor/`). Update this index when a
 |-------------|----------------|-----|
 | `lib.rs` / `EditorPluginGroup` | Ordered plugin bundle, lib/bin split | ADR 0008, architecture.md |
 | `shared::components::BrushDesc` / `shared::hydration::brushes` | Persisted brush authoring data and generated runtime mesh hydration | brushes.md, ADR 0021 |
-| `scene/` | Level I/O, schema, viewport render-target setup | architecture.md |
+| `scene/` | Level I/O, tabs, composition materialization, schema, viewport render-target setup | architecture.md, multi-scene-composition.md, ADR 0026 |
 | `viewport/` | Camera, selection, gizmos, render views | architecture.md |
 | `play/` | PIE session, editor mode state | architecture.md |
-| `assets/` | Catalog, asset DB, static mesh artifacts, `thumbnails/`, `materials.rs`, prefab overrides v2 | this file (below), ADR 0017 |
-| `project/` | Workspace, settings UI, user prefs | roadmap Phase 1 |
+| `play/audio_preview.rs` / `game::audio` | Non-dirty editor audition and authored runtime playback/bus adapter | audio-authoring.md, ADR 0030 |
+| `assets/animation.rs` / `ui/animation_inspector.rs` / `game::animation` | Generated animation manifests, controller authoring/preview, and runtime state adapter | animation-authoring.md, ADR 0031 |
+| `assets/` | Catalog, asset DB, static mesh artifacts, `thumbnails/`, `materials.rs`, prefab overrides v2 | this file (below), prefab-authoring.md, ADR 0017, ADR 0027 |
+| `shared::prefab_overrides` | Versioned stable override schema and editor-independent runtime application | prefab-authoring.md, ADR 0027 |
+| `project/` | Workspace, settings UI, user prefs, support diagnostics | roadmap Phase 1 |
+| `project/session.rs` | Versioned XDG session document, clean marker, and safe resume | session-recovery.md, ADR 0024 |
+| `project/diagnostics_bundle.rs` | Privacy-bounded transactional support report export | session-recovery.md, ADR 0024 |
+| `project/launcher.rs` | Strict project inspection, CLI activation, recent filtering, and sandbox scaffolding | project-launcher.md, ADR 0025 |
 | `ext/` | Command palette, BRP, game panel adapters | ADR 0007 |
 | `ui/mod.rs` | Dock layout, unified viewport, menus | README controls |
+| `ui/scene_tabs.rs` | Main-toolbar scene tabs and composition controls | multi-scene-composition.md, ADR 0026 |
 | `ui/component_registry.rs` | Editor-visible component descriptors and Add Component palette metadata | ADR 0018 |
 | `ui/asset_browser/` | Asset Browser tree, grid/list, details | roadmap Phase 4b |
 | `history/` | Undo/redo command stack | README controls |
 | `crates/scene` | Schema stamp/migrate/validate (shared) | ADR 0006, ADR 0008 |
 | `ext/extensibility.rs` | Command registry, `ActorInspectorSection`, palette | Phase 6 |
-| `operators.rs` | Operator lifecycle/status bridge for commands and future modal tools | BS-JD-004 |
+| `operators.rs` / `operators/test_harness.rs` | Operator lifecycle/status bridge and reusable regression invariants | operator-regression-testing.md, BS-JD-502 |
 | `ext/game_inspector.rs` | Game-registered inspector sections | Phase 6 |
 
 ## Design intentions (stable)
@@ -41,16 +56,17 @@ Docs for the in-process egui editor (`crates/editor/`). Update this index when a
 - **Dedicated egui `Camera2d`** at full window — never attach `PrimaryEguiContext` to a viewport-cropped 3D camera (NaN layout panic).
 - **Unified viewport** uses one render-to-texture target for both the editor fly camera and the possessed player camera so HDR/atmosphere is not broken by sub-viewport cropping.
 - **PIE:** F8 possess/eject while sim runs; **F6** pauses/resumes simulation in Play; project settings drive shared rendering for the active viewport camera.
-- **Asset browser** mirrors the on-disk `assets/` directory with project tree, breadcrumb, search/filter/sort, grid/list views, texture/model/material thumbnails, a details pane, and context-aware row/menu actions; narrow docks prioritize content, keep the root panel fixed, switch list view to a compact single-column layout, and hide tree/details panes when they would crowd the content area. The footer stays pinned while only the project tree, asset content, and details panels scroll. **Built-ins** holds spawnable primitives and lights. **Materials** folder scans `assets/materials/*.ron`, renders material thumbnails on a sphere using `MaterialDesc`, and exposes shader-schema-driven parameters/textures in the details editor; **Shaders** holds shader schema RON files. glTF/GLB/FBX rows can expand into a shelf of normalized embedded mesh, material, and texture subassets with independent generated thumbnails. Mesh subassets can be selected, dragged into the viewport, or placed from details/context menus; material subassets render source-material spheres; texture subassets can be applied to the selected actor. Model import settings are staged with **Apply** / **Revert**, asset context menus can regenerate thumbnails, material asset details edit shared `MaterialAsset` fields, and file asset deletion moves sources/generated artifacts into `assets/.trash/`. Before thumbnail loading, glTF sources preflight local external buffers/images and show a stable non-retryable failure state when a dependency is missing instead of repeatedly invoking the asset loader.
+- **Asset browser** mirrors the on-disk `assets/` directory with project tree, breadcrumb, search/filter/sort, grid/list views, texture/model/material thumbnails, a details pane, and context-aware row/menu actions; narrow docks prioritize content, keep the root panel fixed, switch list view to a compact single-column layout, and hide tree/details panes when they would crowd the content area. The footer stays pinned while only the project tree, asset content, and details panels scroll. **Built-ins** holds spawnable primitives and lights. **Materials** folder scans `assets/materials/*.ron`, renders material thumbnails on a sphere using `MaterialDesc`, and exposes shader-schema-driven parameters/textures in the details editor; **Shaders** holds shader schema RON files. **Audio** accepts Bevy-supported Ogg/Vorbis and Speex (`.ogg`, `.oga`, `.spx`), WAV, MP3, and FLAC clips under `assets/audio/`, with a dedicated filter, waveform icon, format/file details, and stable registry-backed references that retain a runtime source path. glTF/GLB/FBX rows can expand into a shelf of normalized embedded mesh, material, and texture subassets with independent generated thumbnails. Mesh subassets can be selected, dragged into the viewport, or placed from details/context menus; material subassets render source-material spheres; texture subassets can be applied to the selected actor. Model import settings are staged with **Apply** / **Revert**, asset context menus can regenerate thumbnails, material asset details edit shared `MaterialAsset` fields, and file asset deletion moves sources/generated artifacts into `assets/.trash/`. Before thumbnail loading, glTF sources preflight local external buffers/images and show a stable non-retryable failure state when a dependency is missing instead of repeatedly invoking the asset loader.
 - **Static mesh renderer** — model drag/drop defaults to `ActorKind::StaticMesh + StaticMeshRenderer` using normalized artifacts under `assets/meshes/generated/`. Renderer slots store imported `EditorAssetRef` mesh/material references, not source FBX/glTF paths. `SceneInstance` placement keeps the legacy `ImportedModel + ModelRef` path for full scene playback.
+- **Animation authoring** — glTF/GLB imports generate UUID-keyed rig/clip manifests and expandable skeleton/clip shelves. Clip drag creates an animated actor or adds one exact-signature-compatible state to a selected imported model through typed history. `AnimationControllerDesc` exposes named states, ranges, loop/speed, default/crossfade, and non-dirty runtime-backed preview; project validation resolves the same stable refs and blocks animated/skinned FBX with conversion guidance. Production acceptance remains open in Gitea #46. See [animation-authoring.md](animation-authoring.md) and [ADR 0031](../adr/0031-animation-authoring-runtime-contract.md).
 - **Brush authoring** — `ActorKind::Brush + BrushDesc` stores persisted convex blockout faces, validates authored geometry in the inspector and Window → Brush Diagnostics, and hydrates active valid brushes into generated mesh children. See [brushes.md](brushes.md).
 - **Draw Brush** — `B`, toolbar pencil, or command `brush.draw` enters a floor-polygon draw mode. LMB places snapped points, Backspace removes the last point, Enter locks the outline for height editing, mouse up/down adjusts height, and Enter/LMB creates additive prism brushes through history. Esc/right-click cancels. Simple concave outlines decompose into convex brush parts; self-intersections remain blocked.
 - **Brush edit modes** — with a brush selected, `1`/`2`/`3`/`4` enter vertex, edge, face, and clip element modes. Element modes show brush handles in the viewport, own LMB picking, support Shift multi-select, show a mode badge, and Esc returns to object mode. Vertex/edge/face selections use the standard `W`/`E`/`R` gizmo at the element pivot and commit undoable `SetBrush` edits. Clip previews a bounds-based half-brush and commits with Enter; command-palette intersect, convex merge, and subtract operations use the same preview/commit lifecycle for conservative cuboid/prism blockout.
 - **Collider split** — imported mesh collision lives in a separate `ColliderDesc::StaticMesh` plus optional `RigidBodyDesc`; renderer slots own only render visibility, shadows, mesh, and material references.
 - **Material assets** — `MaterialAsset` RON (`label` + `MaterialDesc`) is shader-schema aware. Actor material edits live on the actor `MaterialDesc`; static mesh slot material refs are source/default selectors, and content-browser asset inspectors are the path for editing shared material assets.
-- **Prefab overrides** — `PrefabInstance.overrides_ron` stores transform/material/child-visibility overrides; inspector collapsible groups with **Apply** / **Revert** (replaces transform-only revert v1).
-- **Theme selections** use explicit high-contrast selected text and muted blue fills so hierarchy, asset browser, and inspector selection rows stay readable.
-- **Hierarchy** shows authored objects plus useful runtime context (`Player`, `PlayerCamera`, Project Sun) while keeping runtime rows read-only.
+- **Prefab authoring** — shared `PrefabOverrides` targets generated actors by nested anchor chain plus stable `ActorId`, and applies reflected property/component plus same-layer structural operations in editor and game hydration. The editor supports scoped Revert and transactional **Apply to source** with three-way conflict checks, exact-file undo guards, and recoverable changed/broken/conflict states. `HydratedPrefabMember` keeps generated content out of owner serialization; linked-root saves retain local structure as variants. **Unpack Layer** preserves nested links, while **Convert to Local** recursively removes them. See [prefab-authoring.md](prefab-authoring.md) and [ADR 0027](../adr/0027-stable-prefab-ownership-and-variants.md).
+- **Visual language** uses a near-black industrial shell, a compact Blacksite identity mark, restrained amber actions/primary selection, cyan secondary selection, semantic status colors, stable grouped controls, and shared elevated viewport chips. Primary/secondary selection roles remain consistent across hierarchy rows, viewport x-ray shells/corner brackets, the selection HUD, and transform interactions. See [visual-language.md](visual-language.md).
+- **Hierarchy** shows authored objects plus useful runtime context (`Player`, `PlayerCamera`, Project Sun). Ordinary runtime rows remain read-only; generated prefab rows expose override-aware inspection and same-layer remove/reparent actions while rejecting cross-instance/layer and composition-boundary drops. Locks prevent selection, gizmos, drag participation, structural targets, and mutating context actions. Authored reparenting preserves world placement and records parent/local-transform/manual-order changes as one undoable command.
 - **Player placement** is authored through `PlayerSpawn`; selecting the runtime player in Edit mode redirects to a saved `Player Start`.
 - **World lighting** has two layers: project default sun/ambient settings, and optional scene-authored directional `LightDesc` overrides. **Scene → Lighting** menu and **Rendering** panel (Window) restore project sun or bake a scene directional from project settings. **Apply** in Project Settings updates ambient and sun illuminance live.
 - **Rendering** — `GiMode` + post-process volumes; see [rendering.md](rendering.md). **Window → Rendering** shows requested/effective active-camera stack, fallback reason, Solari eligibility, viewport GI badge, and volume HUD.
@@ -58,11 +74,12 @@ Docs for the in-process egui editor (`crates/editor/`). Update this index when a
 - **Command palette** (`Ctrl+P`): opens centered, clears and focuses the filter, selects the first result, searches both human-facing labels and stable command IDs, and supports arrow-key selection and Enter to run. Commands include `scene.reset_lighting`, `brush.draw`, `brush.subtract`, `brush.intersect`, `brush.merge_convex`, `rendering.create_volume`, `rendering.select_volumes_at_camera`, `rendering.focus_active_volumes`, `selection.group`, `selection.focus`, `selection.reset_transform`, and play commands.
 - **Editor input routing** gives egui text fields first claim on keyboard input. Viewport shortcut keys require viewport pointer focus and are suspended while RMB/MMB camera navigation is active.
 - **ActorKind** is required on saved level objects (schema v2). Save strips hydrated ECS before writing `.scn.ron`.
-- **Scene visualizers** expose actor root icons, colliders, lights, player spawns, prefab/model anchors, Project Sun, and runtime player/camera markers without changing saved scene data. Viewport options include actor icon size and transform gizmo size sliders.
+- **Scene persistence and recovery** use transactional same-directory writes for authored scenes and bounded user-local recovery snapshots for dirty saved scenes. Recovery runs every 120 seconds by default, keeps five generations, never marks the scene clean, and appears as a status/File-menu restore or discard action when newer than the authored file. Restore leaves the original scene dirty until manually saved. See [ADR 0023](../adr/0023-transactional-scene-persistence-and-recovery.md).
+- **Scene visualizers** expose actor root icons, colliders, lights, player spawns, gameplay markers, volumes, prefab/model anchors, Project Sun, and runtime player/camera markers without changing saved scene data. Spot lights show inner/outer cones and cameras show near/far frusta. Viewport options independently gate visualizer categories and include actor icon and transform-gizmo size sliders.
 - **Clean game-view overlay** (`G`) hides editor chrome, grid, selection outlines, transform gizmos, actor root icons, visualizers, and selectable proxies without changing camera ownership; `Ctrl+G` toggles grid.
-- **Viewport shading** (toolbar): **Lit** (default WYSIWYG), **Unlit** (base-color debug), **Colliders** (hide meshes, emphasize collider gizmos). Light gizmos show range spheres, spot cones, and directional sun arrows. A **mode badge** (bottom-right of the viewport) shows the active mode; Collider mode displays a warning banner.
-- **Hierarchy** sort modes (**Manual**, **Name**, **Type**) use stable tie-breakers so duplicate names (e.g. several `Pillar` rows) do not reorder on every click. Drag-and-drop reparenting disables panel scroll-to-drag; drop indicators appear only while dragging.
-- **Viewport picking**: click selects nearest object, generated mesh child resolved to its authored actor, actor root icon, or visualizer hit, with actor icons preferred when clicked over meshes; **Tab** cycles overlapping targets at the last click (selection pin deferred).
+- **Viewport shading** (toolbar): **Lit** (default WYSIWYG), **Unlit** (base-color debug), **Colliders** (hide meshes, emphasize collider gizmos). The viewport combines active shading/render path in one bottom-right chip, draws a camera-relative X/Y/Z orientation widget, identifies the primary selection in a responsive top-right HUD, and previews asset placement with a pointer card, placement reticle, corner brackets, and highlighted drop boundary.
+- **Hierarchy** sort modes (**Manual**, **Name**, **Type**) use stable tie-breakers so duplicate names (e.g. several `Pillar` rows) do not reorder on every click. Actor drags use the full remaining row width as an attach target, show a pointer-following action card, preserve world transforms, reject cycles, keep selected subtrees intact, auto-expand the new parent, and commit one undoable hierarchy command. **Manual** mode additionally exposes between-row reorder targets and the drag-only **Scene Root** unparent target.
+- **Viewport picking**: click selects nearest object, generated mesh child resolved to its authored actor, actor root icon, or visualizer hit, with actor icons preferred when clicked over meshes; **Tab** cycles overlapping targets at the last click. The selection HUD reports the current overlapping-pick position, and additive selections use an amber primary plus cyan secondary treatment. All unlocked selected actors participate in the grouped transform gizmo and one undoable transform command.
 - **Settings data** lives in `crates/settings`; **settings UI** lives in `settings_ui.rs`.
 
 When implementing or changing any of the above, update this file and the root README in the same change.
diff --git a/docs/editor/animation-authoring.md b/docs/editor/animation-authoring.md
new file mode 100644
index 0000000..066a25e
--- /dev/null
+++ b/docs/editor/animation-authoring.md
@@ -0,0 +1,91 @@
+# Animation Authoring
+
+Blacksite's first production animation path supports skinned glTF 2.0 models (`.gltf` and `.glb`).
+It normalizes imported rig and clip metadata into generated manifests, keeps authored scene data
+independent of Bevy's runtime graph/player components, and uses the same controller contract in
+editor preview, PIE, and standalone builds.
+
+## Import And Placement
+
+Place animated sources under `assets/` and refresh or reimport them from the Asset Browser. The
+registry writes `assets/animations/generated/<asset-id>.animation.ron` beside the existing static
+mesh artifact. Expanding a model row shows:
+
+- skeleton entries with joint count and signature summary;
+- animation clips with duration and event count;
+- mesh, material, and texture entries from the static import contract.
+
+Skeleton rows are inspect-only. Dragging an animation clip into the viewport creates one
+`ImportedModel` actor with a stable `ModelRef` and `AnimationControllerDesc` and selects it for
+immediate inspection. When an imported-model actor is selected, the same drag assigns the clip as a
+new controller state instead. Assignment is one undoable command and requires an exact
+skeleton-signature match.
+
+Skinned primitive rows are inspect-only because their vertex data requires the source skin
+hierarchy. Their thumbnails render the complete source scene, and drag/place actions direct authors
+to place the model or an animation clip instead of creating an invalid detached mesh.
+
+## Controller Inspector
+
+The Animation Controller component exposes the selected skeleton, default crossfade, named states,
+default state, clip, loop, speed, and optional playback range. State IDs are gameplay keys and must
+be non-empty and unique; labels are presentation only. Component add, remove, reset, copy, paste,
+and property changes use typed editor history and participate in scene dirty tracking.
+
+The Preview section selects a state, plays or pauses it, stops playback, and scrubs within the
+authored range. Preview requests use the game runtime adapter and do not change the controller,
+history, or scene dirty state. Entering PIE clears any paused edit-mode scrub so the authored
+default state can run; leaving PIE clears transient playback while retaining authored data.
+
+## Runtime API
+
+Gameplay changes state by sending a validated request through `game::animation`:
+
+```rust
+game::animation::request_animation_state(
+    world,
+    game::animation::AnimationStateRequest::new(actor, "run").with_crossfade(0.15),
+)?;
+```
+
+An omitted crossfade uses the controller default. Invalid actor or state requests return an error
+and preserve current playback. If edited controller data cannot rebuild its runtime graph, the old
+graph is stopped and cleared instead of continuing stale playback. `AnimationGraph`,
+`AnimationPlayer`, transitions, preview state, and hydrated model roots are runtime-only and never
+serialize into authored scenes.
+
+## Stable Identity And Moves
+
+`ModelRef`, skeleton references, and clip references carry the model registry UUID. Generated
+artifacts are keyed by that UUID; source paths are cached resolution and repair hints. When one
+model is moved or renamed on disk, catalog refresh reconciles it by its animation-manifest content
+hash, preserves the UUID, and regenerates both manifests with the new source path. An identical copy
+is not treated as a move while the original still exists. Ambiguous content matches intentionally
+receive a new identity rather than silently binding the wrong asset.
+
+Legacy path-only `ModelRef` values remain readable and use their cached path. Reassign or replace a
+legacy model actor to opt it into stable move resolution.
+
+Skeleton compatibility hashes the exact Bevy 0.19 glTF node-name segments and bind poses, including
+whitespace and slash characters. The readable joint paths shown by the editor are deliberately not
+used as identity. Animation-manifest schema v1 artifacts must be reimported to generate schema v2
+signatures.
+
+## Validation And Format Boundary
+
+Interactive diagnostics and `cargo validate-levels` resolve registry UUIDs, generated manifests,
+stable subasset IDs, source dependencies, default/state IDs, playback ranges, speeds, crossfades,
+runtime format support, exact source-content fingerprints, and exact rig compatibility. Findings
+identify the owning actor and controller property and include a repair action. Packaging includes
+the same source files and generated artifacts checked by validation.
+
+FBX remains supported for static model import only. An FBX containing skin deformers or animation
+stacks emits a blocking diagnostic directing the author to convert it to glTF. Animation v1 does
+not support one glTF asset containing animation channels under multiple top-level roots, because
+Bevy creates a separate `AnimationPlayer` for each root. Split those rigs into separate assets or
+export them beneath one common root. Animation v1 also does not provide implicit retargeting, blend
+trees, a visual state graph, root motion, IK, or motion matching.
+
+See [ADR 0031](../adr/0031-animation-authoring-runtime-contract.md) for the persistent/runtime
+boundary and [the working implementation plan](../../.cursor/plans/animation_authoring_2026-07-11.plan.md)
+for acceptance gates.
diff --git a/docs/editor/architecture.md b/docs/editor/architecture.md
index d082a51..deba28b 100644
--- a/docs/editor/architecture.md
+++ b/docs/editor/architecture.md
@@ -20,7 +20,7 @@ Native-only dependencies (`rfd`, BRP HTTP) stay in `editor`. `settings`, `shared
 
 | Plugin | Role |
 |--------|------|
-| `GamePlugin` | Shared runtime: rendering, player, sim schedule |
+| `GamePlugin` | Shared runtime: rendering, player, sim schedule; standalone default-level bootstrap |
 | `ProjectSettingsPlugin` | Load `assets/project.ron`, emit changes, sync `SimTuning` |
 | `ProjectIoPlugin` | User prefs, workspace metadata, window title inputs |
 | `EditorStatePlugin` | `EditorMode` (Edit/Play), `PlayPossession`, camera/input gating |
@@ -59,11 +59,41 @@ Workflow: run `cargo watch … build -p game_hot` in one terminal, `cargo run -p
 
 Do not add egui or editor-only state to the `settings` crate.
 
+## Scene Persistence And Recovery
+
+`scene/scene_io.rs` owns authored scene extraction and user-facing save/load requests;
+`scene/recovery.rs` owns transactional byte persistence and machine-local recovery generations.
+The editor sets `GameSceneBootstrap::defer_default_level`, so `SceneIoPlugin` alone materializes
+the startup document. A standalone `GamePlugin` instead attaches a schema-aware `DynamicWorldRoot`
+for `ProjectSettings.default_level`; it never runs this automatic load inside the editor.
+Serialization always rebuilds stripped hydration state before returning, including error paths.
+Manual writes use same-directory temporary files plus sync/rename, while recovery snapshots live
+under the user state directory and never clear scene dirty state. Newer recovery is discovered on
+load and exposed through File menu restore/keep-copy/discard actions; it is never restored
+automatically. Keeping a copy writes a separate transactional scene without changing the active
+scene or retiring recovery.
+The bounded in-session scene I/O event log feeds the Diagnostics window so a later status update
+does not erase a save or recovery failure.
+See [ADR 0023](../adr/0023-transactional-scene-persistence-and-recovery.md).
+
+`project/session.rs` owns the independent versioned restart document under the user state
+directory. It snapshots allowlisted paths, panel visibility, dock/hierarchy metadata, and camera
+bookmarks, writes a running marker at startup, and records clean `AppExit`. Abnormal sessions do
+not auto-open the prior scene; the explicit safe-resume prompt is the only path back. See
+[ADR 0024](../adr/0024-versioned-editor-session-state.md).
+
+`project/diagnostics_bundle.rs` exports a separate, transactional support report from an explicit
+metadata allowlist. It summarizes build/renderer identity, project paths, dirty state, aggregate
+validation, the prior crash boundary, and the bounded Scene I/O log without serializing ECS data,
+asset contents, environment values, host identity, credentials, or operator state.
+
 The active project root is a startup boundary because `AssetPlugin.file_path`, project settings,
-the asset catalog, and the initial level must agree before editor systems initialize. The editor
-currently starts in the repository project root. Cross-project selection and scaffolding belong in
-the planned BS-JD-001 launcher before the main app is built; do not reintroduce in-process project
-switching that only changes settings metadata while leaving the AssetServer on the old root.
+the asset catalog, and the initial level must agree before editor systems initialize.
+`project/launcher.rs` validates and activates explicit roots before the app exists, filters
+user-local recents, and scaffolds only missing/empty sandbox destinations. The graphical BS-JD-001
+chooser builds on this contract. Do not reintroduce in-process project switching that changes only
+settings metadata while leaving `AssetServer` on the old root; see
+[ADR 0025](../adr/0025-project-root-is-a-startup-boundary.md).
 
 ## Camera and viewport model
 
@@ -121,9 +151,9 @@ The egui layer lives under `crates/editor/src/ui/`:
 | `diagnostics.rs` | Detailed stats (Window → Diagnostics, Asset Browser footer) |
 | `layout.rs` | Dock layout RON persistence in `editor_prefs.ron` |
 
-The Viewport fills the tab (no inline help text). Gizmo/grid/play controls sit on a semi-transparent overlay, and `G` hides editor-only overlays for a clean game view. A blue status bar prioritizes `SceneIo.status` feedback and also shows scene path/dirty state, mode, selection count, history, and the active operator. Long feedback is truncated responsively and available in a hover tooltip. Dock layout restores from `~/.config/bevy-fps/editor_prefs.ron` on startup; **View → Reset Layout** restores defaults.
+The Viewport fills the tab (no inline help text). Gizmo/grid/play controls sit on a near-black semi-transparent overlay, and `G` hides editor-only overlays for a clean game view. The fixed dark status strip prioritizes `SceneIo.status` feedback and also shows scene path/dirty state, mode, selection count, history, and the active operator. Long feedback is truncated responsively and available in a hover tooltip. Dock layout restores from `~/.config/bevy-fps/editor_prefs.ron` on startup; **View → Reset Layout** restores defaults.
 
-**Follow-up (Phase 4b):** hierarchy expand/collapse persistence, inspector search, and richer per-asset previews.
+**Follow-up (Phase 4b):** inspector search and richer per-asset previews.
 
 ## PIE state machine
 
@@ -151,7 +181,7 @@ On play enter/exit the editor snapshots **player sim state only** (transform, ve
 1. User edits entities with `LevelObject` + reflectable components from `shared`.
 2. `EditorOnly` entities (cameras, helpers) are filtered from hierarchy and save; visualizer proxies can be picked but resolve back to source entities.
 3. Player placement is stored as `PlayerSpawn`; the runtime `Player` is never serialized.
-4. `SceneIo` writes native Bevy dynamic scenes under `assets/levels/`, routed through the Bevy-free `scene::document::SceneDocument` seam. The document layer preserves the current RON storage while exposing stable actor/component document concepts and patch vocabulary for tools.
+4. `SceneIo` writes native Bevy dynamic scenes under `assets/levels/`, routed through `scene::document::SceneDocument`. The active tab is materialized in the ECS world; inactive tabs retain normalized authored snapshots and independent dirty/recovery state. `SceneComposition` resources reference validated project-relative subscenes by stable IDs, and runtime-only `ComposedSceneMember` ownership prevents child actors from being flattened into the owner save. See [multi-scene-composition.md](multi-scene-composition.md) and ADR 0026.
 5. Hydration systems in `game` spawn meshes, colliders, lights, and static mesh renderer parts at runtime. Level-object roots are initialized with Bevy visibility hierarchy components before generated children are attached, so authoring `EditorVisibility` participates in normal visibility propagation. `ActorId` and `ComponentInstanceId` are the persisted identities; raw Bevy `Entity` IDs are runtime-only and must not become tool-facing document IDs.
 6. Brush actors store authored convex geometry as `BrushDesc`; hydration rebuilds generated mesh children from those faces and strips the children before save.
 
@@ -172,8 +202,11 @@ User-facing actions route through the operator lifecycle in `operators.rs`: begi
 commit, cancel, disabled reason, and status text. The first bridge wraps command-palette and queued
 editor commands as immediate operators, while existing `EditorHistory` commands remain the undo
 payload. Asset placement, mesh-subasset placement, texture apply, and material apply actions now
-use immediate operators from `assets::operators`; modal tools should use the same status path as
-they migrate.
+use immediate operators from `assets::operators`; texture/material changes across a selection use
+one `SetMaterialGroup` command. Draw Brush, brush CSG, clip, and element gizmo paths publish the
+same preview/commit/cancel phases. `operators/test_harness.rs` verifies authored deltas, dirty
+state, helper cleanup, undo grouping, and undo/redo restoration; see
+[operator-regression-testing.md](operator-regression-testing.md).
 
 PIE stop restores player simulation state only; authored `LevelObject` edits made during PIE remain in the scene.
 
@@ -192,7 +225,10 @@ PIE stop restores player simulation state only; authored `LevelObject` edits mad
 | `history/` | Undo commands + plugin |
 | `ui/` | egui dock shell |
 
-Shared scene schema lives in `crates/scene` (stamp/migrate/validate on save, load, and CI).
+Shared scene schema lives in the Bevy-free `crates/scene` crate (stamp/migrate/validate on save,
+load, and CI). `game::schema_world_loader` is the runtime adapter that validates and unwraps the
+schema envelope before Bevy deserializes versioned prefab assets; both game and editor install it
+through `GamePlugin`.
 
 ## HDR / swapchain invariant
 
diff --git a/docs/editor/audio-authoring.md b/docs/editor/audio-authoring.md
new file mode 100644
index 0000000..08d83b3
--- /dev/null
+++ b/docs/editor/audio-authoring.md
@@ -0,0 +1,62 @@
+# Audio Authoring
+
+Blacksite provides a complete scene-to-runtime audio loop for Bevy-supported Ogg/Vorbis and Speex,
+WAV, MP3, and FLAC clips. Audio assets live under `assets/audio/`; the Asset Browser assigns a
+stable registry ID plus the runtime project path used by standalone games and packages.
+
+## Authoring Workflow
+
+- Drag an audio clip into empty viewport space to create an `AudioSource` actor at the snapped drop
+  position. With an audio source selected, dropping another clip assigns it through one undoable
+  command.
+- The Audio Source Inspector controls clip, gain, pitch, loop, autoplay, 2D/spatial blend,
+  attenuation distances/curve, and stable bus routing. **Audition** uses the editor camera as the
+  spatial listener; **Stop** ends it immediately.
+- Add an Audio Listener component from the Audio category when a scene needs an explicit listener.
+  The highest-priority enabled listener wins; stable actor ID order is the deterministic fallback.
+- Source/listener root icons and selected-only attenuation/listener gizmos can be hidden with the
+  Audio option in Viewport options.
+
+Audition entities are `EditorOnly`. They are stopped on PIE entry, scene replacement, source
+deletion, natural clip completion, or explicit Stop. Audition does not mutate the source descriptor,
+push history, or mark the active scene dirty. The preview owns a transient listener that follows the
+editor camera without replacing camera components, and a failed clip load stops with an editor
+status message instead of leaving a silent preview active.
+
+## Buses
+
+**Edit -> Project Settings -> Audio Buses** edits the project bus graph. `master`, `music`, and `sfx`
+are required stable IDs; labels, gain, and mute state are editable. Custom buses receive stable IDs,
+route through a parent, and may be removed while unused. Apply/Save is disabled while the graph has
+duplicate IDs, missing parents, cycles, invalid gain, or missing required buses.
+
+Runtime code can change user/session mixer state through `game::audio::AudioBusRuntime` without
+rewriting project settings. Effective gain includes the complete parent route. A muted parent mutes
+all descendants.
+
+## Runtime And PIE
+
+`game::audio::GameAudioPlugin` derives Bevy `AudioPlayer`, sink, and `SpatialListener` state from the
+authored descriptors. A continuous spatial blend uses equal-power 2D and spatial voices between the
+endpoints; selected attenuation is applied from the effective listener position. Spatial backend
+coordinates are normalized inside the authored audible radius, so left/right panning does not add a
+second distance falloff on top of the Inspector curve. F6 pauses/resumes existing PIE voices, while
+stopping PIE clears derived voices so the next session starts from the authored autoplay state.
+
+The runtime exposes `play_authored_audio_source`, `stop_authored_audio_source`, and
+`reset_authored_audio_runtime` for gameplay/session control. `AudioRuntimeDiagnostics` reports the
+active CPAL backend, default output device, and compiled codec set without making headless content
+validation depend on an audio device.
+
+## Validation And Sample
+
+Interactive validation, `cargo validate-levels`, and packaging share checks for:
+
+- missing, unsafe, excluded, unreadable, or Git LFS pointer clips;
+- unresolved clip identities and unsupported codec extensions;
+- invalid gain, pitch, spatial blend, attenuation, listener ear gap, or bus references;
+- invalid project bus graphs and tied highest-priority enabled listeners.
+
+`assets/levels/audio_authoring_showcase.scn.ron` and
+`assets/audio/editor_audition_tone.ogg` provide a small deterministic source/listener fixture for
+save/load, audition, PIE, headless validation, and package smoke tests.
diff --git a/docs/editor/brp.md b/docs/editor/brp.md
index 2f4233f..b70262e 100644
--- a/docs/editor/brp.md
+++ b/docs/editor/brp.md
@@ -104,13 +104,25 @@ External automation can enqueue the same names through the editor command queue
 
 ## CI / headless validation
 
-Validate committed levels without the editor UI:
+Validate committed levels and prefab dependency graphs without the editor UI:
 
 ```bash
 cargo validate-levels
+# JSON for CI, packaging, or external tools
+cargo validate-levels --json
 ```
 
-This runs `scene::validate_level_file` (schema migrate + **authoring-only** component check).
+This runs the shared `scene::validate_project` report used by the editor Diagnostics window. It
+validates authored levels and recursive prefab/composition graphs, emits an owner-attributed
+dependency manifest, reports blocking content references, and exits nonzero on errors.
+`--project <path>` validates another project root. The graph pass validates link paths, stable actor
+identity, cycles, anchors, and override payloads without starting the editor. The same report scans
+project settings and asset roots, registry/import dependencies, generated mesh manifests, material
+and shader documents, post effects, brush geometry, collider dimensions, Git LFS hydration, and
+platform requirements. Validation and packaging share one runtime-inclusion policy: hidden/editor
+trees, source formats such as PSD/Blend, symlinks, and unreadable traversal are blocking when a
+runtime dependency reaches them. `asset.git_lfs_object_missing` is blocking; run `git lfs pull` in
+the project checkout and rerun validation before building a package.
 
 ```bash
 cargo test -p shared
diff --git a/docs/editor/build-and-package.md b/docs/editor/build-and-package.md
new file mode 100644
index 0000000..ee9cbd8
--- /dev/null
+++ b/docs/editor/build-and-package.md
@@ -0,0 +1,77 @@
+# Build and package
+
+## Editor workflow
+
+Open **Build > Build Package** or the **Build** panel. Select `development`, `qa`, or `release`, then
+choose **Build** or **Build and Run**. Compilation and packaging run in the background and stream into
+the panel. **Cancel** terminates the active packager/compiler process tree. **Reveal Output** opens
+the last successful package directory. The editor refuses to start a package while any scene tab is
+modified; save all tabs first. Closing the editor cancels and joins the build worker.
+
+Every build validates before and after compilation. Blocking findings must be repaired through the
+owning scene actor or asset. The final asset snapshot must remain unchanged while staging is
+assembled; otherwise the build asks for a retry and leaves the previous package untouched.
+
+## Headless workflow
+
+```bash
+cargo package-project --profile development
+cargo package-project --profile qa
+cargo package-project --profile release
+
+# Validate/package another checkout
+cargo package-project --project /path/to/project --profile release
+```
+
+`--skip-build --artifact /path/to/game` is reserved for package-pipeline tests or repackaging an
+already-built matching Cargo artifact. Normal editor and CI workflows must not use it. Cargo JSON is
+the authoritative executable location for ordinary builds, including custom target directories.
+
+## Profiles and output
+
+Profiles live in `assets/build_profiles/*.ron`. The editor's sandbox scaffold creates all three
+standard profiles even though the engine Cargo workspace remains separate from that project root.
+Output must use a dedicated `dist/<name>/` directory under a real, non-symlinked project `dist/`.
+A non-empty destination is replaceable only when its `build-metadata.json` proves that the packager
+owns it; profile typos therefore cannot prune source or unrelated user files. Runtime asset symlinks
+and unreadable traversal entries are also rejected. The standard outputs are `dist/development`,
+`dist/qa`, and `dist/release`; `dist/` is ignored by Git.
+
+`development` uses the optimized non-LTO package profile and forces Forward GI in the packaged
+settings for portable iteration. `qa` retains line tables and preserves the authored rendering
+policy. `release` preserves authored rendering, uses thin LTO, and strips symbols. `dev` and
+`hot-reload` Cargo features are editor iteration modes and are intentionally rejected by packaging.
+Windows MSVC QA output also includes `blacksite.pdb`; Linux QA line tables remain embedded in the
+binary. Profile-selected defaults must be regular `.scn.ron` scenes under `assets/levels/`, where the
+shared validator audits their complete component dependency graph as well as schema/composition. The current native
+layout supports desktop Linux and Windows targets; web, Android, iOS, and macOS application bundles
+need dedicated platform packaging and are rejected instead of producing an incomplete output.
+
+Each output contains:
+
+- `blacksite` (`blacksite.exe` on Windows);
+- `blacksite.pdb` for Windows MSVC QA profiles;
+- runtime `assets/` with editor/recovery/source-only content excluded;
+- `build-metadata.json` with the toolchain, commit/dirty state, profile inputs, and BLAKE3 content
+  hashes.
+
+Files are assembled in an authenticated sibling staging directory copied from prior output, then
+rehashed and promoted only after metadata and the content manifest are complete. Staging never shares
+writable file inodes with the published package; Windows removal also clears read-only attributes only
+inside authenticated owned work trees. A per-output OS lock blocks concurrent publishers. The next
+run removes an owned interrupted staging tree and restores a verified prior backup; unknown lookalike
+files/directories are left untouched and reported. A cancellation, validation error, or I/O failure
+never publishes a partial package.
+
+Run a package from its output directory so Bevy resolves the packaged `assets/` root:
+
+```bash
+cd dist/release
+./blacksite
+```
+
+The standalone binary loads `default_level` from its packaged `assets/project.ron` through the same
+schema-aware dynamic-scene loader used by runtime prefab assets. The editor leaves that authored
+startup to `SceneIo`; its generated arena remains only as the failure fallback when the startup scene
+cannot be loaded. Build and Run reports a clear host mismatch instead of trying to execute a
+cross-compiled package for a different operating system or CPU architecture.
diff --git a/docs/editor/multi-scene-composition.md b/docs/editor/multi-scene-composition.md
new file mode 100644
index 0000000..28d6908
--- /dev/null
+++ b/docs/editor/multi-scene-composition.md
@@ -0,0 +1,49 @@
+# Multi-Scene Tabs And Composition
+
+Blacksite keeps scene-document controls at the right end of the existing main toolbar. Each tab has
+its own path and dirty marker; **+** creates an untitled tab and **x** closes a tab with a
+save/discard/cancel prompt when needed. **File > Open Scene...** opens another tab instead of
+discarding the active document. Save and Save As affect the active tab, while project switching
+offers to save every modified tab.
+
+## Composition workflow
+
+The **Composition** menu beside the tabs edits the active scene's persisted `SceneComposition`:
+
+- **Add Subscene...** accepts a validated `.scn.ron` under the active project root.
+- **Loaded** loads or unloads that reference from the active world.
+- **Locked** routes every loaded actor through the hierarchy's read-only selection, gizmo, drag,
+  and mutation guards.
+- **Focus** selects a loaded actor owned by the reference and frames it in the editor camera.
+- Remove deletes only the reference; it never deletes the referenced scene file.
+
+Composition edits mark only the owner tab dirty and participate in undo/redo. Loaded child actors
+carry runtime-only ownership metadata and are excluded when the owner saves, so editing the
+composition cannot flatten child content into the parent file. To edit a child scene, open it as
+its own tab.
+
+## Validation and PIE
+
+References use stable scene/reference IDs and project-relative paths. Editor load and
+`cargo validate-levels` recursively reject missing files, path escapes, duplicate IDs, and cycles
+before replacing the active world. Hidden references remain validated even though they are not
+loaded. Nested loaded scenes inherit a locked ancestor's read-only boundary.
+
+The active world is the authoritative composition for PIE and viewport rendering. Switching tabs
+is disabled during Play. The safe materialization boundary clears entity-edit undo history on tab
+activation because current history commands contain runtime entity IDs; composition changes
+themselves are stable-resource commands and remain undoable until the next tab activation.
+
+## Recovery and migration
+
+Every dirty saved tab receives its own bounded transactional recovery generations, including tabs
+that are currently inactive. Untitled tabs must be saved once before automatic recovery can assign
+them a durable scene path.
+
+Legacy scenes need no manual migration. They receive a deterministic `legacy:<project path>` scene
+identity in memory and write the current `SceneComposition` resource on the next normal save.
+Project startup still opens the manifest's `default_level`; clean session recovery resumes only the
+last active authored scene, not the full transient tab set.
+
+See [ADR 0026](../adr/0026-stable-scene-composition-and-active-document.md) for the ownership and
+materialization decision.
diff --git a/docs/editor/operator-regression-testing.md b/docs/editor/operator-regression-testing.md
new file mode 100644
index 0000000..600f352
--- /dev/null
+++ b/docs/editor/operator-regression-testing.md
@@ -0,0 +1,54 @@
+# Operator Regression Testing
+
+Blacksite editor operators and modal tools must preserve the authored scene across preview,
+commit, cancellation, validation failure, and undo/redo. Tests share
+`operators::test_harness::OperatorInvariantHarness` so a new tool proves the same contract instead
+of inventing local assertions.
+
+## Required invariants
+
+Every production operator test must cover the paths it exposes:
+
+| Path | Required proof |
+|------|----------------|
+| Commit | Expected authored entity delta, exact undo-group delta, dirty state, committed phase |
+| Cancel or commit failure | No authored entity delta, no new history, prior dirty state, canceled phase |
+| Blocked start | Commit closure never runs; authored state, history, and dirty state are unchanged |
+| Preview helpers | No helper component remains after commit or cancel |
+| Undoable commit | `assert_undo_redo_round_trip` restores both initial and committed projections |
+| Continuous edit | The entire interaction creates one history command, not one per frame or target |
+
+The harness intentionally fails with the invariant name in the assertion message. Tests may add
+domain assertions, but should not replace these shared lifecycle checks.
+
+## Adding a tool test
+
+1. Build a minimal `World` with `ActiveOperator`, `EditorHistory`, and `SceneIo`. Add tool-specific
+   selection/resources and `SelectedEntity` when history helpers update selection.
+2. Capture `OperatorInvariantHarness` immediately before starting the operation.
+3. Run the real operator entry point or the same production commit/cancel function used by its
+   input system.
+4. Call `assert_committed`, `assert_canceled`, or `assert_blocked` with the expected authored and
+   undo deltas.
+5. For helpers, call `assert_no_helpers::<ToolHelper>`. For undoable work, project the meaningful
+   state through `assert_undo_redo_round_trip`.
+
+Do not satisfy a lifecycle test by constructing an `EditorCommand` and checking only its label.
+The test must mutate a world and prove restoration.
+
+## Current coverage
+
+| Workflow | Coverage |
+|----------|----------|
+| Generic `EditorOperator` | Commit cleanup, commit failure rollback, blocked no-op |
+| Asset placement | Commit, dirty state, single undo, authored spawn round trip |
+| Sub-asset placement | Missing dependency commit failure leaves no side effects |
+| Texture/material assignment | Multi-actor grouped undo; missing material failure; empty-selection block |
+| Draw Brush | Full modal-state cancel; decomposed multi-brush grouped commit and round trip |
+| Brush CSG | Pending-preview cancel; merge commit/deletion grouped round trip |
+| Brush clip and element gizmo | Clip grouped geometry round trip; Escape rollback and helper cleanup |
+| Transform gizmo finalization | Multi-target continuous edit grouped into one undo command |
+
+Terrain strokes and physics-settle sessions are roadmap tools, not current production operators.
+Their implementation tickets must add harness fixtures before those tools can pass their own exit
+gates; Gitea issue BS-JD-502 remains the umbrella until that coverage exists.
diff --git a/docs/editor/prefab-authoring.md b/docs/editor/prefab-authoring.md
new file mode 100644
index 0000000..5ea6319
--- /dev/null
+++ b/docs/editor/prefab-authoring.md
@@ -0,0 +1,156 @@
+# Prefab Authoring
+
+Blacksite prefabs are schema-versioned `.scn.ron` documents under `assets/`. A placed prefab stays
+linked through its authored `PrefabInstance`; entities loaded from the source are runtime-owned
+members and are never flattened into the scene that contains the instance.
+
+## Create and place a prefab
+
+1. Select one or more authored actor roots.
+2. Choose **File > Save Selection As Prefab...** and save under `assets/prefabs/`.
+3. Place the resulting prefab from the Asset Browser. The placed root exposes a **Prefab Instance**
+   component with its stable asset ID and source path.
+
+Saving expands the selected authored hierarchy. Hydrated prefab members and composed-scene members
+are excluded from the prefab file. Missing or duplicate authored `ActorId` values are repaired before
+a direct prefab save; a failed save restores the original in-memory IDs.
+
+## Stable identity and layering
+
+An override target is not a runtime `Entity` or display name. `PrefabActorPath` stores the target
+actor's stable `ActorId` plus the `ActorId` chain of every nested prefab anchor needed to reach it.
+Two nested copies may therefore contain the same source actor IDs without sharing override identity.
+
+The hydrated result is resolved from least to most specific:
+
+1. the source prefab document;
+2. each nested link's own overrides;
+3. the containing variant document and its authored local structure;
+4. the overrides on the placed instance.
+
+The override schema and runtime application live in `crates/shared`, so standalone and packaged game
+builds apply the same data without loading the editor plugin.
+
+## Instance overrides
+
+Select a generated prefab member to edit its override layer. The current inspector exposes:
+
+- **Property overrides** for Transform position, rotation, and scale, plus Material base color,
+  metallic, and roughness.
+- **Component overrides** for adding, replacing, or removing `MaterialDesc`, plus visibility on
+  direct or nested generated actors.
+- **Structural overrides** for removing a source actor or reparenting generated actors within the
+  same instance layer. Hierarchy **Unparent override** writes the same stable structural operation.
+
+These edits update `PrefabInstance.overrides_ron`; they do not immediately edit the source asset.
+Use **Revert** at field scope, **Revert component overrides**, **Revert actor overrides**, or
+**Revert all** at instance scope. Each edit/revert is one undoable prefab-state command.
+
+Legacy root transform/material data and name-keyed visibility data still load. Current operations
+use the full stable `PrefabActorPath`, so repeated leaf `ActorId` values in sibling nested instances
+remain distinct.
+
+## Apply to source
+
+**Apply to source** is an explicit source-asset write, not another name for storing an instance
+override. It is available for a field, component, generated actor, or all operations on the placed
+instance.
+
+For a direct target, Blacksite patches the linked source document. For a target reached through a
+nested `instance_chain`, it moves the operation into the immediate nested link recorded by that
+source layer. This preserves the base/variant boundary instead of unexpectedly mutating the deepest
+leaf prefab.
+
+Before writing, Blacksite compares the recorded base with the current source value, serializes the
+patched document, validates the complete dependency graph, and performs an atomic same-directory
+write. The history entry stores exact before/after source bytes and the old/new instance state.
+Undo or redo is blocked if another process changed the source after the command; Blacksite reports
+the block instead of overwriting that external work.
+
+## Source status and conflict recovery
+
+The **Prefab Instance** card combines hydration state, transitive graph validation, recorded source
+revision, stable target resolution, and base-value checks:
+
+- **Loading source** - wait for hydration before unpacking or editing generated targets.
+- **Ready** - the graph is valid, the recorded revision matches, and overrides resolve cleanly.
+- **Base not tracked** - a legacy instance has no revision. **Accept current base** records it without
+  changing override values.
+- **Base changed** - the source graph changed but no semantic conflict was found. Inspect the result,
+  then **Accept current base** or relink.
+- **Override conflict** - a target disappeared or a source property/component/parent changed from the
+  base captured by an override. **Keep overrides** rebases the stored bases, while **Take source**
+  removes only semantically conflicting operations. **Remove stale overrides** cleans unresolved
+  legacy visibility keys; **Relink...** selects another valid source.
+- **Broken source** - a source is missing or its graph/path/identity validation failed. Hydrated
+  generated state is removed, the authored anchor remains repairable, and **Retry source** or
+  **Relink source...** starts one clean hydration attempt.
+- **Invalid overrides** - the serialized override payload is malformed. **Discard invalid data**
+  resets that payload explicitly.
+
+Accept, keep/take, stale cleanup, relink, and source Apply participate in undo/redo according to
+their scope. Reload and Retry refresh hydration without creating an authoring history entry.
+
+## Local children and hierarchy overrides
+
+Authored local actors may be created or reparented below a linked instance root or another authored
+local actor. Nested linked prefabs may be placed there as well. Those entries remain normal
+scene-owned content: they can be selected, transformed, reordered, saved, and undone.
+
+Rows carrying `HydratedPrefabMember` are generated context. Their Transform/Material fields are
+edited through overrides rather than direct source mutation. Generated actors may be removed or
+reparented only within the same owning instance and nested layer. Cross-instance, cross-layer, and
+composition-boundary drops are rejected. Between-row ordering of generated siblings is not modeled,
+and authored local children cannot yet attach directly to a generated source member.
+
+## Save a variant
+
+Variants use normal linked-prefab composition rather than a separate asset type:
+
+1. Start with a linked prefab instance and author its instance override layer.
+2. Add local children or nested prefab instances below its root/local structure.
+3. Select the linked root and choose **Create Variant...** in the Prefab Instance inspector, or use
+   **File > Save Selection As Prefab...**.
+
+The saved prefab contains the base `PrefabInstance` link, its stable overrides, and local authored
+structure. Hydrated base members are excluded. Placing the variant therefore evaluates base, nested
+layers, variant, and placed-instance overrides in order without duplicating generated actors.
+
+Applying an override on a nested source actor writes it to the immediate link in the variant/source
+document; open the leaf prefab itself when the intended change should affect every use of that leaf.
+
+## Unpack and convert
+
+**Unpack Layer** removes only the selected outer `PrefabInstance`/`PrefabRef` ownership link and
+turns its hydrated members into authored local actors. Nested prefab instances remain linked, and
+outer overrides targeting them are folded into those retained links transactionally. Undo restores
+the outer link and removes the local copy; redo restores the captured authored result.
+
+**Convert to Local** recursively removes the selected outer link and every generated or authored
+local nested prefab link below it. Every converted hydrated source actor receives a fresh local
+`ActorId`, including actors from different nested documents that originally reused an ID. The
+operation is one undo step and redo uses captured snapshots, so it does not depend on the source
+files still being present.
+
+## Validation and remaining acceptance
+
+Prefab save, editor load, project inspection, and `cargo validate-levels` recursively inspect linked
+`PrefabInstance` components. Validation rejects missing sources, unsafe paths (including symlink
+escapes), non-`.scn.ron` sources, cycles (including path aliases), empty asset IDs, incomplete link
+anchors, malformed outer or inner override payloads, missing authored `ActorId` values, and
+duplicate IDs within a document. The committed `assets/prefabs/example_base.scn.ron` ->
+`example_nested.scn.ron` -> `example_variant.scn.ron` chain is the healthy production-format
+fixture for this gate.
+
+The shared format can apply registered reflected property/component operations, but the current
+authoring UI exposes the Transform and Material fields/components listed above. Generated sibling
+ordering and direct local-child attachment to a generated member are not yet override operations.
+Variants remain ordinary composed prefab documents rather than a separately named asset type.
+
+Production acceptance closed in Gitea issue
+[#43](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/43) after the
+complete workspace suite, recursive headless validation, packaged release startup, and live editor
+placement/inspection regression passed against the committed fixture chain.
+
+See [ADR 0027](../adr/0027-stable-prefab-ownership-and-variants.md) for the ownership, stable identity,
+layering, and source-write contract.
diff --git a/docs/editor/project-launcher.md b/docs/editor/project-launcher.md
new file mode 100644
index 0000000..9e25388
--- /dev/null
+++ b/docs/editor/project-launcher.md
@@ -0,0 +1,63 @@
+# Project Launcher And Sandboxes
+
+Blacksite treats the project root as a pre-engine startup choice. The root must contain a valid
+`assets/project.ron`; its default level must be project-relative, exist, and pass the shared scene
+validator before the editor constructs `AssetPlugin` or loads project content.
+
+Use an explicit root from the command line:
+
+```bash
+cargo run -p editor --features dev -- --project /path/to/project
+cargo run -p editor --bin project_launcher --features dev
+```
+
+Omitting `--project` preserves direct-open behavior for the current working directory. Invalid or
+unknown arguments fail before GPU initialization with an actionable terminal error.
+
+## Manifest identity
+
+New manifests include:
+
+- `project_id`: stable UUID or repository-owned identifier;
+- `project_kind`: `Game` or `Sandbox`;
+- `template_version`: scaffold/template compatibility version;
+- `capabilities`: forward-compatible feature tags;
+- `default_level`: regular `.scn.ron` initial authored scene under `assets/levels/`.
+
+New manifests include the `audio` capability, `assets/audio` asset root, and the validated Master,
+Music, and SFX bus graph. Bus references use the stable IDs `master`, `music`, and `sfx`; labels are
+presentation only.
+
+Older manifests remain readable through serde defaults. The launcher uses a non-persisted legacy
+path identity when an old manifest has no `project_id`.
+
+## Sandbox contract
+
+Sandbox creation only accepts a missing or empty destination. It creates the standard audio,
+levels, materials, meshes, models, rendering, shader, texture, registry, and trash directories; a
+schema-current empty `assets/levels/main.scn.ron`; a transactional sandbox manifest; and
+development, QA, and release profiles under `assets/build_profiles/` targeting that scene. The
+project remains content-only: editor packaging runs from the installed engine workspace while
+passing this project root explicitly. Scaffolding never merges into a non-empty directory.
+
+Recent projects remain user-local. Missing, invalid, and duplicate roots are removed from launcher
+presentation, and the last scene is shown only when it still exists under that project root.
+
+## Switching and desktop launch
+
+**File > Switch Project...** writes a clean editor session, starts the Project Browser as an
+independent process, and exits. Opening a recent or browsed project performs the reverse handoff:
+the browser exits only after a new editor process has been accepted by the user's service manager.
+This keeps renderer, asset server, import registry, and project settings rooted consistently.
+
+On the supported Linux workstation, the **Blacksite Editor** desktop entry provides an **Open
+Project Browser** action. Its wrapper builds both editor binaries into the shared target directory,
+shows the normal startup splash, avoids duplicate browser processes, and preserves the Wayland,
+session-bus, graphics, and XDG environment required by the detached process.
+
+The browser's **New Sandbox** workflow requires a missing or empty folder and a non-empty name.
+Creation failures remain in the browser as status text; a successful scaffold is validated and
+opened through the same process handoff as an existing project.
+
+See [ADR 0025](../adr/0025-project-root-is-a-startup-boundary.md) for why project switching must
+cross a process boundary.
diff --git a/docs/editor/roadmap.md b/docs/editor/roadmap.md
index a4f1992..000e329 100644
--- a/docs/editor/roadmap.md
+++ b/docs/editor/roadmap.md
@@ -2,7 +2,7 @@
 
 Phased work for the in-process editor (`crates/editor`). Status reflects the current codebase; update this file when closing a phase.
 
-## Production editor program (complete — P5 partial)
+## Production editor program (P5 cleanup remaining)
 
 **Goal:** Zero-debt authoring loop — hydration modules, mandatory `ActorKind`, actor inspector only, schema v2 migrations. See [ADR 0009–0012](../adr/0009-authoring-vs-hydrated.md) and `.cursor/plans/editor_rendering_and_ux_*.plan.md`.
 
@@ -11,9 +11,9 @@ Phased work for the in-process editor (`crates/editor`). Status reflects the cur
 | P0 Hydration + lighting | **Done** | `shared/hydration/*`, strip-on-save, schema v2 migrate, live ambient/sun, Rendering Diagnostics |
 | P1 Actor model | **Done** | `ActorKind`, `validate_actor`, history snapshots, ADRs 0009–0012 |
 | P2 Actor inspector | **Done** | `ui/actor_inspector/`; removed `DefaultInspectorConfigPlugin` + ECS dump on Inspector tab |
-| P3 Hierarchy tree + sibling order | **Done** | `HierarchySiblingIndex`, tree outliner, DnD reorder, visibility/lock |
+| P3 Hierarchy tree + sibling order | **Done** | `HierarchySiblingIndex`, tree outliner, full-row DnD attach/reorder/root, world-transform preservation, cycle guards, visibility/lock |
 | P4 Viewport modes | **Done** | Lit / Unlit / Collider toolbar, light gizmo overlays, Tab pick cycle |
-| P5 Assets + prefabs | **Partial** | `MaterialAsset`, `assets/thumbnails/sources/`; prefab overrides v1; delete legacy `fbx_preview` when cache fully unified |
+| P5 Assets + prefabs | **Partial** | Prefab v2 is production-accepted with stable nested identity, scoped/runtime overrides, committed base/nested/variant fixtures, source Apply/conflict recovery, and local conversion; legacy `fbx_preview` cleanup remains |
 | P6 Extensibility + CI | **Done** | `ActorInspectorSection`, palette commands, BRP policy, hydration/scene CI |
 | P7 Docs + debt audit | **Done** | ADRs 0009–0012, [debt-audit.md](debt-audit.md), CI matrix |
 
@@ -39,7 +39,7 @@ Phased work for the in-process editor (`crates/editor`). Status reflects the cur
 | `ProjectWorkspace` resource | Done | Root, settings path, dirty flags |
 | User prefs (`~/.config/bevy-fps/editor_prefs.ron`) | Done | Recent levels, load on startup |
 | Window title from project + scene | Done | `project_io::window_title` |
-| Project launcher and scaffolding | Planned | BS-JD-001; project selection must happen before AssetServer startup, so the former in-process New/Open menu was removed |
+| Project launcher and scaffolding | Done | Project Browser validates/scaffolds before AssetServer startup; `--project`, recent projects, and clean process handoff preserve the startup boundary |
 | Dock layout persistence | Done | RON in `editor_prefs.ron`; View → Reset Layout |
 
 ## Phase 2 — Viewport excellence
@@ -100,13 +100,13 @@ Phased work for the in-process editor (`crates/editor`). Status reflects the cur
 
 | Item | Status | Notes |
 |------|--------|-------|
-| Dark pro theme + Phosphor icons | Done | `ui/theme.rs`, `ui/fonts.rs`, high-contrast selection states, overlay toolbars |
+| Blacksite dark visual system + Phosphor icons | Done | Near-black shell, Blacksite toolbar mark, semantic amber/cyan states, `ui/theme.rs`, `ui/fonts.rs`, overlay toolbars |
 | Fixed status bar | Done | Replaces Status dock tab; exposes scene I/O and operator feedback alongside scene/mode/selection/history |
 | Viewport overlay toolbar | Done | Gizmo/grid/focus/options/game-view toggle (play moved to main toolbar) |
 | Main toolbar transport | Done | Centered Play/Pause/Stop/Eject; taller bar (~52px) |
 | Pause in PIE | Done | `PlayPaused` freezes sim while staying in Play (`F6`) |
 | Dock layout persistence | Done | `ui/layout.rs` + `UserPreferences.dock_layout` |
-| Hierarchy tree + type icons | Partial | Authored + generated/runtime rows with icons; expand/collapse state still future |
+| Hierarchy tree + type icons | Done | Authored + generated/runtime rows, persistent expansion, full-row attach targets, subtree-safe multi-drag, transform-preserving undo |
 | Actor inspector (authoring-only) | Done | Transform + `LightDesc`/`MaterialDesc`/…; no bevy_inspector dump |
 | Inspector component headers | Done | Header + Transform + component cards + Add Component footer |
 | Asset browser project/file views | Done | Folder tree, breadcrumb, search/filter/sort, grid/list, details pane, texture + model thumbnails |
@@ -121,7 +121,7 @@ Phased work for the in-process editor (`crates/editor`). Status reflects the cur
 | Model import formats | Done | glTF/GLB + FBX (binary); `.fbm` sidecar copy on import |
 | Thumbnails | Done | Textures via asset load; glTF albedo fast-path; FBX/untextured models via offscreen studio |
 | Import settings per asset | Done | Scale/collider/LOD in registry + details pane |
-| Prefab workflow | Partial | `PrefabInstance`, save-as-prefab, unpack; **Revert Transform** v1 in inspector; full override apply/revert future |
+| Prefab workflow | Done | Shared stable nested property/component/structural overrides, recursive validation, committed variant fixtures, transactional source Apply, conflict recovery, and undoable outer unpack/recursive local conversion passed headless, packaged-runtime, and live editor acceptance in Gitea #43 |
 
 ## Phase 6 — Extensibility
 
@@ -137,6 +137,23 @@ Phased work for the in-process editor (`crates/editor`). Status reflects the cur
 | BRP authoring-only policy | Done | [brp.md](brp.md) |
 | CI: `shared` hydration, `scene` migration + allowlist | Done | See `.github/workflows/ci.yml` |
 
+## Production Readiness Program
+
+The live program is tracked by Gitea
+[`#1`](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/1),
+with implementation sequencing in
+`.cursor/plans/blacksite_production_readiness_2026-07-10.plan.md`.
+
+| Milestone | Exit condition | Status |
+|-----------|----------------|--------|
+| M6 Reliability, recovery, and project workflow | Transactional save/recovery, stable sessions, project launcher, hardened hierarchy/prefabs, multi-scene composition | Implementation complete; all six scoped issues are closed after prefab #43 passed workspace, headless, packaged-runtime, and live editor acceptance |
+| M7 Content production and shipping | Build/package profiles, content release gate, animation, audio, navigation, collaborative safety | Active; #44, #45, and #47 are complete. Audio passed automated, headless, live editor/PIE, and packaged-runtime acceptance. Remaining scoped work is animation #46, navigation #48, source-control safety #49, and final readiness gate #50 |
+
+Production readiness is not inferred from feature count. Gitea
+[`#50`](https://git.spacetrainclubhouse.com/Falling-Metal-Interactive/Blacksite/issues/50)
+requires representative-project workflows, soak and performance evidence, headless validation,
+packaging, recovery QA, first-hour signoff, and no open P0 blocker.
+
 ## Documentation maintenance
 
 When you ship editor behavior changes:
diff --git a/docs/editor/session-recovery.md b/docs/editor/session-recovery.md
new file mode 100644
index 0000000..97ab61f
--- /dev/null
+++ b/docs/editor/session-recovery.md
@@ -0,0 +1,38 @@
+# Editor Session Recovery
+
+Blacksite stores restart metadata in the user state directory, separate from project assets and
+source-controlled settings:
+
+- `$XDG_STATE_HOME/blacksite-editor/session.ron`, or
+- `~/.local/state/blacksite-editor/session.ron` when `XDG_STATE_HOME` is unset.
+
+The file uses schema v1 and is written transactionally. It contains project and scene paths, dock
+and hierarchy metadata, non-destructive panel visibility, finite viewport camera bookmarks, and a
+clean-shutdown marker. It never contains scene contents, unsaved tool previews, environment values,
+or credentials.
+
+## Restart behavior
+
+- **Clean shutdown:** the last authored scene and non-destructive UI state are restored.
+- **Abnormal shutdown:** the editor opens its normal safe scene and displays **Recover Editor
+  Session**. **Resume Last Scene** opens only the previous authored scene. **Continue Safe** keeps
+  the startup scene. Modal tools and dirty preview state are never restored.
+- Dirty scene data remains governed by the independent scene recovery workflow in
+  [ADR 0023](../adr/0023-transactional-scene-persistence-and-recovery.md).
+
+An unknown newer session schema is ignored safely. Legacy unversioned session documents migrate to
+v1 after finite camera bookmark validation.
+
+## Diagnostic bundles
+
+**Window → Diagnostics → Export Diagnostic Bundle** writes a timestamped RON report under
+`$XDG_STATE_HOME/blacksite-editor/diagnostics` or
+`~/.local/state/blacksite-editor/diagnostics`. The write uses the same transactional replace
+primitive as session and scene recovery data.
+
+The v1 report allowlists editor and Bevy versions, target OS/architecture and build profile,
+renderer adapter/backend/driver identity, project and active-scene paths, dirty flags, aggregate
+level/brush validation counts, the prior-abnormal-shutdown flag, and up to 32 bounded Scene I/O
+events. It excludes ECS and scene payloads, asset contents, environment values, host/user identity,
+credentials, access tokens, camera transforms, and modal operator state. Review the plain-text RON
+file before sharing it when project paths are sensitive.
diff --git a/docs/editor/visual-language.md b/docs/editor/visual-language.md
new file mode 100644
index 0000000..03c0c3a
--- /dev/null
+++ b/docs/editor/visual-language.md
@@ -0,0 +1,79 @@
+# Editor Visual Language
+
+Blacksite's editor UI is a dense production tool. Its visual system prioritizes scan speed,
+stable controls, viewport legibility, and unambiguous editing state over decorative surfaces.
+
+## Palette Roles
+
+- Near-black neutral surfaces separate canvas, panels, controls, and elevated popovers without a
+  light-gray cast or single-hue tint.
+- Amber is the Blacksite action accent: active tools, the primary selection, warnings, and
+  rendering paths that need attention.
+- Cyan identifies secondary selections, links, and neutral viewport information.
+- Red, green, and blue are reserved for the X, Y, and Z axes across transform gizmos, the world
+  grid, and the viewport orientation widget.
+- Green and red communicate success/running and error/blocked states. They are not decorative.
+
+## Editor Chrome
+
+- A compact Blacksite mark and amber signal line identify the tool without turning the workspace
+  into a branded landing surface; squared controls and tight radii reinforce the industrial tone.
+- Menus, the grouped creation/file toolbar, centered transport controls, dock tabs, and the status
+  strip keep stable dimensions so mode changes do not shift the workspace.
+- Controls use familiar symbols with hover labels. Persistent text is reserved for state, values,
+  selection identity, and task-specific feedback.
+- Dock tabs use an amber active edge, while splitters and panel borders stay neutral until hovered
+  or dragged.
+- Popovers and viewport chips share one elevated surface, border, corner radius, and shadow.
+
+## Viewport Language
+
+- The top-left toolbar groups transform, coordinate space, shading, grid/snap, visualizer, focus,
+  and display controls.
+- The top-right selection chip identifies the active object, selection count, and overlapping-pick
+  position. It moves below the toolbar when the viewport is narrow.
+- The bottom-right orientation widget and combined shading/render-path chip provide camera and
+  render context without covering scene content.
+- Dragging an asset over the viewport produces an amber placement boundary and compact placement
+  card, pointer reticle, and corner brackets before the drop is committed.
+- Grid lines use minor/major weights. The world X and Z axes retain their gizmo colors.
+
+## Selection And Gizmos
+
+- The first selected object is primary: amber x-ray rim and corner brackets, hierarchy edge, and
+  selection HUD identity.
+- Additional selected objects are secondary: cyan rim, brackets, and hierarchy edge.
+- All unlocked authored objects in a multi-selection receive grouped transform-gizmo targets; a
+  single interaction is captured as one undoable group transform.
+- Transform gizmos use restrained X/Y/Z colors, an amber interaction highlight, larger stable
+  screen size, and translation snapping synchronized with the viewport snap toggle and increment.
+- Brush vertex, edge, and face modes reuse the same palette and enlarge active element handles.
+  Face mode outlines the selected face instead of showing only a center point.
+
+## Drag And Drop
+
+- Drag previews follow the pointer and name both the payload and pending action; they never rely on
+  cursor shape alone.
+- Hierarchy rows expose their full remaining width as attach targets. Amber means attach, cyan
+  means root/reorder, and red means the requested hierarchy would be invalid.
+- Reparenting preserves world placement, keeps selected subtrees intact, expands the new parent,
+  and records parent, sibling order, and local transform in one undoable command.
+- Manual hierarchy sort exposes between-row insertion targets; semantic Name and Type sorts expose
+  parenting without pretending a manual reorder will remain visible.
+
+## Visualizers
+
+- Visualizers preserve semantic category colors while selected objects receive stronger emphasis.
+- Camera visualizers include near and far frustum planes plus a forward vector.
+- Spot lights show inner and outer cones; point lights, directional lights, colliders, spawns,
+  gameplay markers, volumes, prefab/model anchors, and runtime helpers remain independently
+  toggleable.
+- Editor-only visualizers and selection helpers never enter saved scene data.
+
+## Maintenance Rules
+
+- Add shared colors and surface frames in `ui/theme.rs`; do not introduce local panel palettes
+  unless the color has domain meaning.
+- Keep selection semantics consistent across the viewport, hierarchy, inspector, and status bar.
+- New viewport overlays must adapt before they overlap existing controls at narrow widths.
+- Visual polish must preserve picking, undo/redo, clean game view, and scene serialization behavior.
diff --git a/third_party/ron-edit/.cargo_vcs_info.json b/third_party/ron-edit/.cargo_vcs_info.json
new file mode 100644
index 0000000..4223e6e
--- /dev/null
+++ b/third_party/ron-edit/.cargo_vcs_info.json
@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "961f66a7ecb83e674b2ac0e52a3574f5637e7dab"
+  },
+  "path_in_vcs": ""
+}
\ No newline at end of file
diff --git a/third_party/ron-edit/.gitattributes b/third_party/ron-edit/.gitattributes
new file mode 100644
index 0000000..e24ea6b
--- /dev/null
+++ b/third_party/ron-edit/.gitattributes
@@ -0,0 +1 @@
+tests/input/* binary
diff --git a/third_party/ron-edit/.gitignore b/third_party/ron-edit/.gitignore
new file mode 100644
index 0000000..4fffb2f
--- /dev/null
+++ b/third_party/ron-edit/.gitignore
@@ -0,0 +1,2 @@
+/target
+/Cargo.lock
diff --git a/third_party/ron-edit/Cargo.toml b/third_party/ron-edit/Cargo.toml
new file mode 100644
index 0000000..0fd2207
--- /dev/null
+++ b/third_party/ron-edit/Cargo.toml
@@ -0,0 +1,59 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+# Blacksite modifications are documented in PATCH.md.
+
+[package]
+edition = "2021"
+name = "ron-edit"
+version = "0.2.0"
+description = "ron parser preserving all syntax information"
+documentation = "https://docs.rs/ron-edit"
+readme = "README.md"
+keywords = ["parser"]
+categories = ["encoding"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/ModProg/ron-edit"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
+[dependencies.const_format]
+version = "0.2.30"
+
+[dependencies.derive_more]
+version = "0.99.17"
+
+[dependencies.macro_rules_attribute]
+version = "0.1.3"
+
+[dependencies.nom]
+version = "7.1.3"
+
+[dependencies.unicode-ident]
+version = "1.0.8"
+
+[dev-dependencies.include_dir]
+version = "0.7.3"
+
+[dev-dependencies.insta]
+version = "1.28.0"
+features = ["ron"]
+
+[dev-dependencies.ron]
+version = "0.8.0"
+
+[dev-dependencies.serde]
+version = "1.0.154"
+features = ["derive"]
diff --git a/third_party/ron-edit/Cargo.toml.orig b/third_party/ron-edit/Cargo.toml.orig
new file mode 100644
index 0000000..f479766
--- /dev/null
+++ b/third_party/ron-edit/Cargo.toml.orig
@@ -0,0 +1,35 @@
+[package]
+name = "ron-edit"
+version = "0.2.0"
+edition = "2021"
+categories = ["encoding"]
+description = "ron parser preserving all syntax information"
+keywords = ["parser"]
+license = "MIT OR Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/ModProg/ron-edit"
+documentation = "https://docs.rs/ron-edit"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[dev-dependencies]
+include_dir = "0.7.3"
+insta = { version = "1.28.0", features = ["ron"] }
+ron = "0.8.0"
+serde = { version = "1.0.154", features = ["derive"] }
+
+
+[profile.dev.package.insta]
+opt-level = 3
+
+[profile.dev.package.similar]
+opt-level = 3
+
+[dependencies]
+const_format = "0.2.30"
+derive_more = "0.99.17"
+macro_rules_attribute = "0.1.3"
+nom = "7.1.3"
+unicode-ident = "1.0.8"
diff --git a/third_party/ron-edit/LICENSE-APACHE b/third_party/ron-edit/LICENSE-APACHE
new file mode 100644
index 0000000..da3ea28
--- /dev/null
+++ b/third_party/ron-edit/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a peretual,
+      worldwide, non-exclusive, no-cpharge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+     agreed to in writing, Licensor provides the Work (and each
+      Contributor provides it s Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/third_party/ron-edit/LICENSE-MIT b/third_party/ron-edit/LICENSE-MIT
new file mode 100644
index 0000000..7c5aea4
--- /dev/null
+++ b/third_party/ron-edit/LICENSE-MIT
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Roland Fredenhagen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/third_party/ron-edit/PATCH.md b/third_party/ron-edit/PATCH.md
new file mode 100644
index 0000000..cceef26
--- /dev/null
+++ b/third_party/ron-edit/PATCH.md
@@ -0,0 +1,25 @@
+# ron-edit 0.2.0 (patched)
+
+Vendored from the `ron-edit` 0.2.0 crates.io release, corresponding to
+upstream commit `961f66a7ecb83e674b2ac0e52a3574f5637e7dab`.
+
+- Upstream: https://github.com/ModProg/ron-edit
+- License: MIT OR Apache-2.0
+- Unmodified license texts are retained as `LICENSE-MIT` and `LICENSE-APACHE`.
+
+Blacksite carries these changes:
+
+- Parse anonymous structs before tuples so component values such as Bevy
+  transforms retain their named fields.
+- Reject an integer parse when the following token continues a floating-point
+  value, preventing values such as `1.0` from being consumed as `1` plus a
+  trailing token.
+- Allow the upstream lifetime-syntax lint while the parser API retains its
+  original borrowed-value signatures.
+- Format the source with the workspace's stable Rust toolchain. The upstream
+  nightly-only `rustfmt.toml` and package-local profile tuning are omitted.
+
+The patch supports lossless scene component/resource RON editing in the scene
+document layer. Remove this vendor patch once a released upstream version
+contains the parser fixes and passes Blacksite's scene document round-trip and
+prefab source-edit regression tests.
diff --git a/third_party/ron-edit/README.md b/third_party/ron-edit/README.md
new file mode 100644
index 0000000..76c4283
--- /dev/null
+++ b/third_party/ron-edit/README.md
@@ -0,0 +1,8 @@
+# ron-edit
+
+[![CI Status](https://github.com/ModProg/ron-edit/actions/workflows/test.yaml/badge.svg)](https://github.com/ModProg/ron-edit/actions/workflows/test.yaml)
+[![Crates.io](https://img.shields.io/crates/v/ron-edit)](https://crates.io/crates/ron-edit)
+[![Docs.rs](https://img.shields.io/crates/v/template?color=informational&label=docs.rs)](https://docs.rs/ron-edit)
+[![Documentation for `main`](https://img.shields.io/badge/docs-main-informational)](https://modprog.github.io/ron-edit/ron_edit/)
+
+Very much WIP ron parser preserving whitespace information.
diff --git a/third_party/ron-edit/src/lib.rs b/third_party/ron-edit/src/lib.rs
new file mode 100644
index 0000000..7bf0fbd
--- /dev/null
+++ b/third_party/ron-edit/src/lib.rs
@@ -0,0 +1,402 @@
+// Blacksite modifications are documented in ../PATCH.md.
+//! Nom parser trying to preserve all information
+//!
+//! Probably the "AST" structure will be reworked quite a bit.
+#![allow(mismatched_lifetime_syntaxes)]
+use std::fmt::{self, Display, Formatter};
+
+use derive_more::Display;
+use macro_rules_attribute::{apply, attribute_alias};
+use nom::branch::*;
+use nom::bytes::complete::*;
+use nom::character::complete::*;
+use nom::combinator::*;
+use nom::error::{context, VerboseError};
+use nom::multi::*;
+use nom::sequence::*;
+use nom::{Finish, Parser};
+#[cfg(test)]
+use serde::Serialize;
+use unicode_ident::{is_xid_continue, is_xid_start};
+pub use value::{Char, Int, List, Map, MapItem, NamedField, Str, Struct, Tuple, Value};
+
+type Error<'a> = VerboseError<&'a str>;
+type IResult<'a, T> = nom::IResult<&'a str, T, Error<'a>>;
+
+mod value;
+
+attribute_alias! {
+    #[apply(ast)] =
+        #[cfg_attr(test, derive(Serialize))]
+        #[derive(Debug, PartialEq)];
+}
+
+#[apply(ast)]
+pub struct File<'s> {
+    pub extentions: Vec<WsLead<'s, Attribute<'s>>>,
+    pub value: WsLead<'s, Value<'s>>,
+    pub trailing_ws: Whitespace<'s>,
+}
+
+impl Display for File<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        self.extentions.iter().try_for_each(|e| write!(f, "{e}"))?;
+        write!(f, "{}{}", self.value, self.trailing_ws)
+    }
+}
+
+impl<'s> TryFrom<&'s str> for File<'s> {
+    type Error = String;
+
+    fn try_from(s: &'s str) -> Result<Self, Self::Error> {
+        match file(s).finish() {
+            Ok(("", file)) => Ok(file),
+            Ok((rem, _)) => Err(format!("unexpected: {rem}")),
+            Err(e) => Err(e.to_string()),
+        }
+    }
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "#{after_pound}!\
+           {after_exclamation}[{after_bracket}enable{after_enable}({extentions}){after_paren}]")]
+pub struct Attribute<'s> {
+    pub after_pound: Whitespace<'s>,
+    pub after_exclamation: Whitespace<'s>,
+    pub after_bracket: Whitespace<'s>,
+    pub after_enable: Whitespace<'s>,
+    pub extentions: Separated<'s, &'s str>,
+    pub after_paren: Whitespace<'s>,
+}
+
+#[apply(ast)]
+pub struct WsLead<'s, T> {
+    pub leading: Whitespace<'s>,
+    pub content: T,
+}
+impl<T: Display> Display for WsLead<'_, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}{}", self.leading, self.content)
+    }
+}
+fn ws_lead<'a, T>(
+    t: impl Parser<&'a str, T, Error<'a>>,
+) -> impl Parser<&'a str, WsLead<'a, T>, Error<'a>> {
+    map(pair(ws, t), |(leading, content)| WsLead {
+        leading,
+        content,
+    })
+}
+
+#[apply(ast)]
+#[derive(Default)]
+pub struct WsFollowed<'s, T> {
+    pub content: T,
+    pub following: Whitespace<'s>,
+}
+impl<T: Display> Display for WsFollowed<'_, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}{}", self.content, self.following)
+    }
+}
+fn ws_followed<'a, T>(
+    t: impl Parser<&'a str, T, Error<'a>>,
+) -> impl Parser<&'a str, WsFollowed<'a, T>, Error<'a>> {
+    map(pair(t, ws), |(content, following)| WsFollowed {
+        content,
+        following,
+    })
+}
+
+#[apply(ast)]
+#[derive(Default)]
+pub struct WsWrapped<'s, T> {
+    pub leading: Whitespace<'s>,
+    pub content: T,
+    pub following: Whitespace<'s>,
+}
+impl<T: Display> Display for WsWrapped<'_, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}{}{}", self.leading, self.content, self.following)
+    }
+}
+fn ws_wrapped<'a, T>(
+    t: impl Parser<&'a str, T, Error<'a>>,
+) -> impl Parser<&'a str, WsWrapped<'a, T>, Error<'a>> {
+    map(tuple((ws, t, ws)), |(leading, content, following)| {
+        WsWrapped {
+            leading,
+            content,
+            following,
+        }
+    })
+}
+
+#[apply(ast)]
+pub enum Ws<'s> {
+    LineComment(&'s str),
+    Space(&'s str),
+    BlockComment(&'s str),
+}
+impl Display for Ws<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Ws::LineComment(c) => write!(f, "//{c}"),
+            Ws::Space(s) => write!(f, "{s}"),
+            Ws::BlockComment(c) => write!(f, "/*{c}*/"),
+        }
+    }
+}
+impl Ws<'_> {
+    pub fn is_comment(&self) -> bool {
+        !matches!(self, Self::Space(_))
+    }
+
+    pub fn is_line_comment(&self) -> bool {
+        matches!(self, Self::LineComment(_))
+    }
+}
+
+#[apply(ast)]
+#[derive(Default)]
+pub struct Whitespace<'s>(pub Vec<Ws<'s>>);
+
+impl Display for Whitespace<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        self.0.iter().try_for_each(|ws| write!(f, "{ws}"))
+    }
+}
+
+#[apply(ast)]
+pub struct Separated<'s, T> {
+    pub values: Vec<WsWrapped<'s, T>>,
+    /// When formatting with [`Display`] comma is only shown when
+    /// [`Self::values`] is not empty.
+    pub trailing_comma: bool,
+    pub trailing_ws: Whitespace<'s>,
+}
+
+impl<T: Display> Display for Separated<'_, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let Self {
+            values,
+            trailing_comma,
+            trailing_ws,
+        } = self;
+        let Some((last, rest)) = values.split_last() else {
+            return write!(f, "{trailing_ws}");
+        };
+        rest.iter().try_for_each(|i| write!(f, "{i},"))?;
+        write!(f, "{last}")?;
+        if *trailing_comma {
+            write!(f, ",")?;
+        }
+        write!(f, "{trailing_ws}")
+    }
+}
+
+#[apply(ast)]
+pub struct ExtentionIdent {}
+
+fn file(input: &str) -> IResult<File> {
+    map(
+        tuple((
+            context("attributes", many0(ws_lead(extention_attr))),
+            context("value", ws_lead(value::value)),
+            ws,
+        )),
+        |(extentions, value, trailing_ws)| File {
+            extentions,
+            value,
+            trailing_ws,
+        },
+    )(input)
+}
+
+#[allow(unused)]
+fn dbg_dmp<'a, O>(
+    context: impl Display,
+    mut p: impl Parser<&'a str, O, Error<'a>>,
+) -> impl FnMut(&'a str) -> IResult<O> {
+    move |s: &str| match p.parse(s) {
+        Err(nom::Err::Error(c)) => {
+            println!("{}: Parsing Error: {} at:\n{:?}", context, c, s);
+            Err(nom::Err::Error(c))
+        }
+        Err(e) => {
+            println!("{}: Error({}) at:\n{:?}", context, e, s);
+            Err(e)
+        }
+        a => a,
+    }
+}
+
+fn extention_attr(input: &str) -> IResult<Attribute> {
+    map(
+        tuple((
+            char('#'),
+            ws,
+            char('!'),
+            ws,
+            char('['),
+            ws,
+            tag("enable"),
+            ws,
+            char('('),
+            separated(ident),
+            char(')'),
+            ws,
+            char(']'),
+        )),
+        |(
+            _,
+            after_pound,
+            _,
+            after_exclamation,
+            _,
+            after_bracket,
+            _,
+            after_ident,
+            _,
+            extentions,
+            _,
+            after_paren,
+            _,
+        )| {
+            Attribute {
+                after_pound,
+                after_exclamation,
+                extentions,
+                after_bracket,
+                after_enable: after_ident,
+                after_paren,
+            }
+        },
+    )(input)
+}
+
+fn ident(input: &str) -> IResult<&str> {
+    alt((
+        recognize(pair(
+            tag("r#"),
+            cut(many1(alt((take_while1(is_xid_continue), is_a("+-."))))),
+        )),
+        recognize(pair(
+            // TODO make issue about adding a take_one(fn(char)->bool)
+            alt((tag("_"), take_while_m_n(1, 1, is_xid_start))),
+            take_while(is_xid_continue),
+        )),
+    ))(input)
+}
+
+fn block_comment(input: &str) -> IResult<Ws> {
+    map(
+        delimited(
+            tag("/*"),
+            recognize(many0(alt((
+                is_not("*/"),
+                recognize(block_comment),
+                take_until1("*/"),
+            )))),
+            tag("*/"),
+        ),
+        Ws::BlockComment,
+    )(input)
+}
+
+fn ws(input: &str) -> IResult<Whitespace> {
+    map(
+        many0(alt((
+            map(is_a("\n\t\r "), Ws::Space),
+            map(
+                preceded(tag("//"), recognize(pair(is_not("\n"), line_ending))),
+                Ws::LineComment,
+            ),
+            block_comment,
+        ))),
+        Whitespace,
+    )(input)
+}
+
+fn separated<'a, T, P: Parser<&'a str, T, Error<'a>>>(
+    p: P,
+) -> impl FnMut(&'a str) -> IResult<Separated<T>> {
+    context(
+        "separated",
+        map(
+            tuple((
+                separated_list0(char(','), ws_wrapped(p)),
+                opt(char(',')),
+                ws,
+            )),
+            |(values, trailing_comma, trailing_ws)| Separated {
+                values,
+                trailing_comma: trailing_comma.is_some(),
+                trailing_ws,
+            },
+        ),
+    )
+}
+
+struct FormatOption<'a, T>(&'a Option<T>);
+impl<T: Display> Display for FormatOption<'_, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self.0 {
+            Some(t) => write!(f, "{t}"),
+            None => Ok(()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use include_dir::include_dir;
+
+    use super::*;
+
+    const INPUTS: include_dir::Dir = include_dir!("$CARGO_MANIFEST_DIR/tests/input");
+
+    #[test]
+    fn whitespace() {
+        assert_eq!(
+            block_comment("/* a */ ").finish().unwrap(),
+            (" ", Ws::BlockComment(" a ".into()))
+        );
+        assert_eq!(
+            block_comment("/* a /* inner */ */ ").finish().unwrap(),
+            (" ", Ws::BlockComment(" a /* inner */ ".into()))
+        );
+        assert_eq!(
+            ws("/* *//* a /* inner */ */").finish().unwrap(),
+            (
+                "",
+                Whitespace(vec![
+                    Ws::BlockComment(" ".into()),
+                    Ws::BlockComment(" a /* inner */ ".into())
+                ])
+            )
+        );
+    }
+
+    #[test]
+    fn ensure_valid_ron() {
+        for file in INPUTS.entries() {
+            let _: ron::Value = ron::de::from_bytes(file.as_file().unwrap().contents()).unwrap();
+        }
+    }
+
+    #[test]
+    fn parse() {
+        for file in INPUTS.entries() {
+            let contents = file.as_file().unwrap().contents_utf8().unwrap();
+            let ron: File = contents.try_into().map_err(|e| eprintln!("{e}")).unwrap();
+
+            assert_eq!(ron.to_string(), contents);
+
+            insta::with_settings!({snapshot_path => "../tests/snapshots"},{
+                insta::assert_ron_snapshot!(file.path().display().to_string(), ron);
+            })
+        }
+    }
+}
diff --git a/third_party/ron-edit/src/value.rs b/third_party/ron-edit/src/value.rs
new file mode 100644
index 0000000..7be5cce
--- /dev/null
+++ b/third_party/ron-edit/src/value.rs
@@ -0,0 +1,240 @@
+// Blacksite modifications are documented in ../PATCH.md.
+use crate::*;
+
+#[apply(ast)]
+#[derive(Display)]
+pub enum Value<'s> {
+    Int(Int<'s>),
+    Float(Float<'s>),
+    Str(Str<'s>),
+    Char(Char<'s>),
+    Bool(bool),
+    List(List<'s>),
+    Map(Map<'s>),
+    Unit(&'s str),
+    Tuple(Tuple<'s>),
+    Struct(Struct<'s>),
+}
+pub(crate) fn value(input: &str) -> IResult<Value> {
+    alt((
+        map(value_int, Value::Int),
+        map(value_float, Value::Float),
+        map(value_str, Value::Str),
+        map(value_char, Value::Char),
+        map(value_list, Value::List),
+        map(value_map, Value::Map),
+        map(value_struct, Value::Struct),
+        map(value_tuple, Value::Tuple),
+        map(ident, Value::Unit),
+    ))(input)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+pub struct Int<'s>(&'s str);
+fn value_int(s: &str) -> IResult<Int> {
+    map(
+        recognize(tuple((
+            sign,
+            alt((
+                is_a("0123456789_"),
+                preceded(
+                    char('0'),
+                    cut(preceded(is_a("box"), is_a("0123456789ABCDEFabcdef_"))),
+                ),
+            )),
+            not(peek(one_of(".eE"))),
+        ))),
+        Int,
+    )(s)
+}
+
+fn sign(s: &str) -> IResult<Option<char>> {
+    opt(alt((char('+'), char('-'))))(s)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+pub struct Float<'s>(&'s str);
+fn value_float(s: &str) -> IResult<Float> {
+    map(
+        // TODO test `double`
+        recognize(tuple((
+            opt(alt((char('+'), char('-')))),
+            alt((
+                tag("inf"),
+                tag("NaN"),
+                recognize(tuple((
+                    alt((
+                        recognize(tuple((digit1, opt(tuple((char('.'), digit0)))))),
+                        recognize(tuple((char('.'), digit1))),
+                    )),
+                    opt(tuple((alt((char('e'), char('E'))), sign, digit1))),
+                ))),
+            )),
+        ))),
+        Float,
+    )(s)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+pub enum Str<'s> {
+    #[display(fmt = "\"{_0}\"")]
+    Baked(&'s str),
+    #[display(fmt = "r{0}\"{content}\"{0}", "\"#\".repeat(*pounds)")]
+    Raw { pounds: usize, content: &'s str },
+}
+fn value_str(s: &str) -> IResult<Str> {
+    alt((
+        map(
+            preceded(
+                char::<&str, Error>('"'),
+                cut(terminated(
+                    recognize(many0(alt((
+                        tag("\\\""),
+                        tag("\\\\"),
+                        tag("\\"),
+                        is_not("\\\""),
+                    )))),
+                    char('"'),
+                )),
+            ),
+            Str::Baked,
+        ),
+        map(raw_string, |(pounds, content)| Str::Raw { pounds, content }),
+    ))(s)
+}
+
+fn raw_string(s: &str) -> IResult<(usize, &str)> {
+    let (s, _) = char('r')(s)?;
+    let (s, pounds) = many0_count(char('#'))(s)?;
+    let terminator = format!("\"{}", "#".repeat(pounds));
+    let res = preceded(
+        char('"'),
+        cut(terminated(
+            take_until(terminator.as_str()),
+            tag(terminator.as_str()),
+        )),
+    )
+    .map(|content| (pounds, content))
+    .parse(s);
+    res
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "'{_0}'")]
+pub struct Char<'s>(pub &'s str);
+fn value_char(s: &str) -> IResult<Char> {
+    map(
+        preceded(
+            char::<&str, Error>('\''),
+            cut(terminated(tag("\\'").or(is_not("'")), char('\''))),
+        ),
+        Char,
+    )(s)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "[{_0}]")]
+pub struct List<'s>(pub Separated<'s, Value<'s>>);
+fn value_list(s: &str) -> IResult<List> {
+    map(
+        preceded(char('['), cut(terminated(separated(value), char(']')))),
+        List,
+    )(s)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "{key}{after_key}:{value}")]
+pub struct MapItem<'s> {
+    pub key: Value<'s>,
+    pub after_key: Whitespace<'s>,
+    pub value: WsLead<'s, Value<'s>>,
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "{{{_0}}}")]
+pub struct Map<'s>(pub Separated<'s, MapItem<'s>>);
+
+fn value_map(s: &str) -> IResult<Map> {
+    context(
+        "map",
+        map(
+            preceded(
+                char('{'),
+                cut(terminated(
+                    separated(tuple((value, ws, char(':'), ws_lead(value))).map(
+                        |(key, after_key, _, value)| MapItem {
+                            key,
+                            after_key,
+                            value,
+                        },
+                    )),
+                    char('}'),
+                )),
+            ),
+            Map,
+        ),
+    )(s)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "{}({fields})", "FormatOption(ident)")]
+pub struct Tuple<'s> {
+    pub ident: Option<WsFollowed<'s, &'s str>>,
+    pub fields: Separated<'s, Value<'s>>,
+}
+fn value_tuple(s: &str) -> IResult<Tuple> {
+    map(
+        pair(
+            opt(ws_followed(ident)),
+            delimited(char('('), separated(value), char(')')),
+        ),
+        |(ident, fields)| Tuple { ident, fields },
+    )(s)
+}
+
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "{key}{after_key}:{value}")]
+pub struct NamedField<'s> {
+    pub key: &'s str,
+    pub after_key: Whitespace<'s>,
+    pub value: WsLead<'s, Value<'s>>,
+}
+#[apply(ast)]
+#[derive(Display)]
+#[display(fmt = "{}({fields})", "FormatOption(ident)")]
+pub struct Struct<'s> {
+    pub ident: Option<WsFollowed<'s, &'s str>>,
+    pub fields: Separated<'s, NamedField<'s>>,
+}
+fn value_struct(s: &str) -> IResult<Struct> {
+    context(
+        "value struct",
+        map(
+            pair(
+                opt(ws_followed(ident)),
+                delimited(
+                    char('('),
+                    separated(map(
+                        tuple((ident, terminated(ws, char(':')), ws_lead(value))),
+                        |(key, after_key, value)| NamedField {
+                            key,
+                            after_key,
+                            value,
+                        },
+                    )),
+                    char(')'),
+                ),
+            ),
+            |(ident, fields)| Struct { ident, fields },
+        ),
+    )(s)
+}
diff --git a/third_party/ron-edit/tests/input/crlf.ron b/third_party/ron-edit/tests/input/crlf.ron
new file mode 100644
index 0000000..8d5b563
Binary files /dev/null and b/third_party/ron-edit/tests/input/crlf.ron differ
diff --git a/third_party/ron-edit/tests/input/sensible.ron b/third_party/ron-edit/tests/input/sensible.ron
new file mode 100644
index 0000000..3b0f0e9
Binary files /dev/null and b/third_party/ron-edit/tests/input/sensible.ron differ
diff --git a/third_party/ron-edit/tests/input/test.ron b/third_party/ron-edit/tests/input/test.ron
new file mode 100644
index 0000000..1da142a
Binary files /dev/null and b/third_party/ron-edit/tests/input/test.ron differ
diff --git a/third_party/ron-edit/tests/insta.rs b/third_party/ron-edit/tests/insta.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/third_party/ron-edit/tests/insta.rs
@@ -0,0 +1 @@
+
diff --git a/third_party/ron-edit/tests/snapshots/ron_edit__test__crlf.ron.snap b/third_party/ron-edit/tests/snapshots/ron_edit__test__crlf.ron.snap
new file mode 100644
index 0000000..798accf
--- /dev/null
+++ b/third_party/ron-edit/tests/snapshots/ron_edit__test__crlf.ron.snap
@@ -0,0 +1,42 @@
+---
+source: src/lib.rs
+expression: ron
+---
+File(
+  extentions: [],
+  value: WsLead(
+    leading: Whitespace([]),
+    content: Struct(Struct(
+      ident: None,
+      fields: Separated(
+        values: [
+          WsWrapped(
+            leading: Whitespace([
+              Space("\r\n    "),
+              LineComment(" File containing \\r\\n endings \r\n"),
+              Space("    "),
+            ]),
+            content: NamedField(
+              key: "something",
+              after_key: Whitespace([]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Int(Int("10")),
+              ),
+            ),
+            following: Whitespace([
+              Space("\r\n"),
+            ]),
+          ),
+        ],
+        trailing_comma: false,
+        trailing_ws: Whitespace([]),
+      ),
+    )),
+  ),
+  trailing_ws: Whitespace([
+    Space("\r\n"),
+  ]),
+)
diff --git a/third_party/ron-edit/tests/snapshots/ron_edit__test__sensible.ron.snap b/third_party/ron-edit/tests/snapshots/ron_edit__test__sensible.ron.snap
new file mode 100644
index 0000000..3fca51a
--- /dev/null
+++ b/third_party/ron-edit/tests/snapshots/ron_edit__test__sensible.ron.snap
@@ -0,0 +1,160 @@
+---
+source: src/lib.rs
+expression: ron
+---
+File(
+  extentions: [],
+  value: WsLead(
+    leading: Whitespace([]),
+    content: Struct(Struct(
+      ident: None,
+      fields: Separated(
+        values: [
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "value",
+              after_key: Whitespace([]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Str(Baked("string")),
+              ),
+            ),
+            following: Whitespace([]),
+          ),
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "value",
+              after_key: Whitespace([]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Float(Float("inf")),
+              ),
+            ),
+            following: Whitespace([]),
+          ),
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "value",
+              after_key: Whitespace([]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Float(Float("+NaN")),
+              ),
+            ),
+            following: Whitespace([]),
+          ),
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "map",
+              after_key: Whitespace([]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Map(Map(Separated(
+                  values: [
+                    WsWrapped(
+                      leading: Whitespace([
+                        Space("\n        "),
+                      ]),
+                      content: MapItem(
+                        key: Unit("A"),
+                        after_key: Whitespace([]),
+                        value: WsLead(
+                          leading: Whitespace([
+                            Space(" "),
+                          ]),
+                          content: Str(Baked("hello")),
+                        ),
+                      ),
+                      following: Whitespace([]),
+                    ),
+                    WsWrapped(
+                      leading: Whitespace([
+                        Space("\n        "),
+                      ]),
+                      content: MapItem(
+                        key: List(List(Separated(
+                          values: [
+                            WsWrapped(
+                              leading: Whitespace([]),
+                              content: Int(Int("1")),
+                              following: Whitespace([]),
+                            ),
+                            WsWrapped(
+                              leading: Whitespace([
+                                Space(" "),
+                              ]),
+                              content: Int(Int("2")),
+                              following: Whitespace([]),
+                            ),
+                          ],
+                          trailing_comma: false,
+                          trailing_ws: Whitespace([]),
+                        ))),
+                        after_key: Whitespace([]),
+                        value: WsLead(
+                          leading: Whitespace([
+                            Space(" "),
+                          ]),
+                          content: Unit("Something"),
+                        ),
+                      ),
+                      following: Whitespace([
+                        Space("\n    "),
+                      ]),
+                    ),
+                  ],
+                  trailing_comma: false,
+                  trailing_ws: Whitespace([]),
+                ))),
+              ),
+            ),
+            following: Whitespace([]),
+          ),
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "r#12+10.3-x",
+              after_key: Whitespace([]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Str(Baked("five")),
+              ),
+            ),
+            following: Whitespace([
+              Space("\n"),
+            ]),
+          ),
+        ],
+        trailing_comma: false,
+        trailing_ws: Whitespace([]),
+      ),
+    )),
+  ),
+  trailing_ws: Whitespace([
+    Space("\n"),
+  ]),
+)
diff --git a/third_party/ron-edit/tests/snapshots/ron_edit__test__test.ron.snap b/third_party/ron-edit/tests/snapshots/ron_edit__test__test.ron.snap
new file mode 100644
index 0000000..aa847a1
--- /dev/null
+++ b/third_party/ron-edit/tests/snapshots/ron_edit__test__test.ron.snap
@@ -0,0 +1,117 @@
+---
+source: src/lib.rs
+expression: ron
+---
+File(
+  extentions: [
+    WsLead(
+      leading: Whitespace([]),
+      content: Attribute(
+        after_pound: Whitespace([
+          Space(" "),
+          LineComment(" a comment\n"),
+          Space("    "),
+        ]),
+        after_exclamation: Whitespace([
+          Space(" "),
+        ]),
+        after_bracket: Whitespace([
+          Space("  "),
+        ]),
+        after_enable: Whitespace([
+          Space("\n"),
+        ]),
+        extentions: Separated(
+          values: [
+            WsWrapped(
+              leading: Whitespace([
+                Space(" "),
+              ]),
+              content: "unwrap_newtypes",
+              following: Whitespace([
+                Space("\n "),
+              ]),
+            ),
+            WsWrapped(
+              leading: Whitespace([
+                Space(" "),
+              ]),
+              content: "implicit_some",
+              following: Whitespace([]),
+            ),
+          ],
+          trailing_comma: false,
+          trailing_ws: Whitespace([]),
+        ),
+        after_paren: Whitespace([
+          Space("\n"),
+        ]),
+      ),
+    ),
+  ],
+  value: WsLead(
+    leading: Whitespace([
+      Space("\n"),
+      LineComment(" Line Comment\n"),
+      BlockComment(" block "),
+      Space("\n"),
+      BlockComment(" Block Comment /* Nested Block Comment */ "),
+      Space("\n"),
+    ]),
+    content: Struct(Struct(
+      ident: None,
+      fields: Separated(
+        values: [
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "value",
+              after_key: Whitespace([
+                Space(" \n\n    "),
+              ]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Str(Baked("hello")),
+              ),
+            ),
+            following: Whitespace([
+              Space(" "),
+              LineComment(" comment\n"),
+              Space("    "),
+            ]),
+          ),
+          WsWrapped(
+            leading: Whitespace([
+              Space("\n    "),
+            ]),
+            content: NamedField(
+              key: "something_else",
+              after_key: Whitespace([
+                Space(" "),
+                BlockComment(" "),
+              ]),
+              value: WsLead(
+                leading: Whitespace([
+                  Space(" "),
+                ]),
+                content: Str(Baked("hi")),
+              ),
+            ),
+            following: Whitespace([
+              Space("\n"),
+            ]),
+          ),
+        ],
+        trailing_comma: false,
+        trailing_ws: Whitespace([]),
+      ),
+    )),
+  ),
+  trailing_ws: Whitespace([
+    Space("\n"),
+  ]),
+)
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index 75e328e..6f7faa5 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -13,10 +13,23 @@ required-features = ["validate-levels"]
 name = "clean-target"
 path = "src/clean_target.rs"
 
+[[bin]]
+name = "package-project"
+path = "src/package_project.rs"
+required-features = ["validate-levels"]
+
 [dependencies]
 walkdir = "2.5"
 scene = { path = "../crates/scene", optional = true }
+settings = { workspace = true, optional = true }
+serde_json = "1"
+serde = { version = "1", features = ["derive"] }
+ron = "0.8"
+blake3 = "1"
+
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
 
 [features]
 default = []
-validate-levels = ["dep:scene"]
+validate-levels = ["dep:scene", "dep:settings"]
diff --git a/xtask/src/package_project.rs b/xtask/src/package_project.rs
new file mode 100644
index 0000000..54e9f0f
--- /dev/null
+++ b/xtask/src/package_project.rs
@@ -0,0 +1,2241 @@
+//! Validation-gated project build and deterministic runtime asset packaging.
+
+use std::collections::BTreeSet;
+use std::fs::{self, OpenOptions};
+use std::io::{BufRead, BufReader, Read, Seek, Write};
+use std::path::{Component, Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+use walkdir::WalkDir;
+
+const PACKAGE_SCHEMA_VERSION: u32 = 1;
+
+#[derive(Debug, Clone, Deserialize)]
+struct BuildProfile {
+    version: u32,
+    name: String,
+    #[serde(default)]
+    cargo_profile: CargoProfile,
+    #[serde(default)]
+    target: Option<String>,
+    #[serde(default)]
+    features: Vec<String>,
+    rendering_tier: RenderingTier,
+    #[serde(default)]
+    default_scene: Option<String>,
+    output_dir: String,
+}
+
+#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize, PartialEq, Eq)]
+enum CargoProfile {
+    #[default]
+    Development,
+    Qa,
+    Release,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+enum RenderingTier {
+    Development,
+    Representative,
+    Shipping,
+}
+
+impl<'de> Deserialize<'de> for RenderingTier {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = String::deserialize(deserializer)?;
+        match value.as_str() {
+            "development" => Ok(Self::Development),
+            "representative" => Ok(Self::Representative),
+            "shipping" => Ok(Self::Shipping),
+            _ => Err(serde::de::Error::custom(format!(
+                "unknown rendering tier `{value}`"
+            ))),
+        }
+    }
+}
+
+impl CargoProfile {
+    fn cargo_name(self) -> &'static str {
+        match self {
+            Self::Development => "package-dev",
+            Self::Qa => "package-qa",
+            Self::Release => "release",
+        }
+    }
+}
+
+#[derive(Debug, Serialize)]
+struct PackageMetadata {
+    schema_version: u32,
+    profile: String,
+    cargo_profile: CargoProfile,
+    target: String,
+    features: Vec<String>,
+    rendering_tier: RenderingTier,
+    default_scene: Option<String>,
+    git_commit: String,
+    git_dirty: bool,
+    project_git_commit: Option<String>,
+    project_git_dirty: Option<bool>,
+    rustc: String,
+    cargo: String,
+    generated_unix_secs: u64,
+    executable: String,
+    debug_symbols: Option<String>,
+    content: Vec<ContentEntry>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+struct ContentEntry {
+    path: String,
+    byte_len: u64,
+    blake3: String,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+struct CopyStats {
+    written: usize,
+    reused: usize,
+    pruned: usize,
+}
+
+#[derive(Debug)]
+struct Options {
+    project_root: PathBuf,
+    profile_name: String,
+    skip_build: bool,
+    artifact: Option<PathBuf>,
+}
+
+#[derive(Debug)]
+struct BuiltArtifacts {
+    executable: PathBuf,
+    companions: Vec<PathBuf>,
+}
+
+fn main() {
+    match run(parse_options()) {
+        Ok(output) => println!("package-project: ready at {}", output.display()),
+        Err(error) => {
+            eprintln!("package-project: {error}");
+            std::process::exit(1);
+        }
+    }
+}
+
+fn parse_options() -> Options {
+    let mut options = Options {
+        project_root: PathBuf::from("."),
+        profile_name: "development".into(),
+        skip_build: false,
+        artifact: None,
+    };
+    let mut args = std::env::args().skip(1);
+    while let Some(argument) = args.next() {
+        match argument.as_str() {
+            "--project" => {
+                options.project_root = PathBuf::from(
+                    args.next()
+                        .unwrap_or_else(|| argument_error("--project requires a path")),
+                );
+            }
+            "--profile" => {
+                options.profile_name = args
+                    .next()
+                    .unwrap_or_else(|| argument_error("--profile requires a name"));
+            }
+            "--skip-build" => options.skip_build = true,
+            "--artifact" => {
+                options.artifact =
+                    Some(PathBuf::from(args.next().unwrap_or_else(|| {
+                        argument_error("--artifact requires a path")
+                    })));
+            }
+            _ => argument_error(&format!("unknown argument `{argument}`")),
+        }
+    }
+    options
+}
+
+fn argument_error(message: &str) -> ! {
+    eprintln!("package-project: {message}");
+    std::process::exit(2);
+}
+
+fn run(options: Options) -> Result<PathBuf, String> {
+    let engine_root = engine_workspace_root()?;
+    let project_root = options
+        .project_root
+        .canonicalize()
+        .map_err(|error| format!("could not resolve project root: {error}"))?;
+    let profile = load_profile(&project_root, &options.profile_name)?;
+    validate_profile(&project_root, &profile)?;
+    let output = resolve_output(&project_root, &profile.output_dir)?;
+
+    validate_release_ready(&project_root, "before compilation")?;
+
+    let built_artifacts = if options.skip_build {
+        let artifact = options.artifact.ok_or_else(|| {
+            "--skip-build requires --artifact <path> from a matching successful Cargo build"
+                .to_string()
+        })?;
+        let artifact = artifact
+            .canonicalize()
+            .map_err(|error| format!("could not resolve supplied artifact: {error}"))?;
+        let artifact_name = artifact.file_name().and_then(|name| name.to_str());
+        if !matches!(artifact_name, Some("game" | "game.exe")) {
+            return Err(
+                "supplied artifact must be a matching Cargo `game` or `game.exe` binary".into(),
+            );
+        }
+        if let Some(target) = &profile.target {
+            let expected_name = if target.contains("windows") {
+                "game.exe"
+            } else {
+                "game"
+            };
+            if artifact_name != Some(expected_name) {
+                return Err(format!(
+                    "supplied artifact does not match profile target `{target}`"
+                ));
+            }
+        }
+        let pdb = artifact.with_extension("pdb");
+        BuiltArtifacts {
+            executable: artifact,
+            companions: pdb.is_file().then_some(pdb).into_iter().collect(),
+        }
+    } else {
+        build_game(&engine_root, &profile)?
+    };
+    let executable_source = &built_artifacts.executable;
+    if !executable_source.is_file() {
+        return Err(format!(
+            "built executable is missing at {}",
+            executable_source.display()
+        ));
+    }
+
+    // The compile can take minutes while the editor remains live. Capture and validate the exact
+    // source state used for this package after the build, then reject any concurrent mutation.
+    let expected_sources = fingerprint_runtime_assets(&project_root)?;
+    validate_release_ready(&project_root, "after compilation")?;
+
+    let effective_target = effective_build_target(&engine_root, &profile, executable_source);
+    validate_supported_target(&effective_target)?;
+    let debug_symbols = select_debug_symbols(&profile, &effective_target, &built_artifacts)?;
+    let _package_lock = PackageLock::acquire(&output)?;
+    recover_interrupted_package(&output)?;
+    let executable_name = packaged_executable_name(&effective_target, executable_source);
+    let mut pending = PendingPackage::new(&output)?;
+    let mut stats = CopyStats::default();
+    pending.seed_from(&output)?;
+    prune_package_root(
+        pending.path(),
+        executable_name,
+        debug_symbols.as_ref().map(|(_, name)| *name),
+        &mut stats,
+    )?;
+    copy_if_changed(
+        executable_source,
+        &pending.path().join(executable_name),
+        &mut stats,
+    )?;
+    if let Some((source, name)) = &debug_symbols {
+        copy_if_changed(source, &pending.path().join(*name), &mut stats)?;
+    }
+
+    let assets_output = pending.path().join("assets");
+    let (mut content, copied_sources) = package_assets(
+        &project_root,
+        &assets_output,
+        profile.default_scene.as_deref(),
+        profile.rendering_tier,
+        &mut stats,
+    )?;
+    let current_sources = fingerprint_runtime_assets(&project_root)?;
+    if copied_sources != expected_sources || current_sources != expected_sources {
+        return Err(
+            "project assets changed while the package was being assembled; no output was replaced, retry the build"
+                .into(),
+        );
+    }
+    content.push(content_entry(
+        &pending.path().join(executable_name),
+        executable_name,
+    )?);
+    if let Some((_, name)) = &debug_symbols {
+        content.push(content_entry(&pending.path().join(*name), name)?);
+    }
+    content.sort_by(|left, right| left.path.cmp(&right.path));
+    let metadata = PackageMetadata {
+        schema_version: PACKAGE_SCHEMA_VERSION,
+        profile: profile.name.clone(),
+        cargo_profile: profile.cargo_profile,
+        target: effective_target,
+        features: profile.features.clone(),
+        rendering_tier: profile.rendering_tier,
+        default_scene: profile.default_scene.clone(),
+        git_commit: command_output(&engine_root, "git", &["rev-parse", "HEAD"]),
+        git_dirty: !command_output(&engine_root, "git", &["status", "--porcelain"]).is_empty(),
+        project_git_commit: command_output_optional(&project_root, "git", &["rev-parse", "HEAD"]),
+        project_git_dirty: command_output_optional(
+            &project_root,
+            "git",
+            &["status", "--porcelain"],
+        )
+        .map(|status| !status.is_empty()),
+        rustc: command_output(&engine_root, "rustc", &["--version"]),
+        cargo: command_output(&engine_root, "cargo", &["--version"]),
+        generated_unix_secs: SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs(),
+        executable: executable_name.into(),
+        debug_symbols: debug_symbols.map(|(_, name)| name.to_string()),
+        content,
+    };
+    let metadata_text = serde_json::to_string_pretty(&metadata)
+        .map_err(|error| format!("could not serialize build metadata: {error}"))?;
+    write_file_atomically(
+        &pending.path().join("build-metadata.json"),
+        metadata_text.as_bytes(),
+    )
+    .map_err(|error| format!("could not write build metadata: {error}"))?;
+    verify_staged_content(pending.path(), &metadata.content)?;
+    pending.publish(&output)?;
+    println!(
+        "package-project: {} file(s) written, {} unchanged file(s) reused, {} stale file(s) pruned",
+        stats.written, stats.reused, stats.pruned
+    );
+    Ok(output)
+}
+
+fn validate_release_ready(project_root: &Path, phase: &str) -> Result<(), String> {
+    let validation = scene::validate_project(project_root);
+    if validation.is_release_ready() {
+        return Ok(());
+    }
+    let summary = validation
+        .findings
+        .iter()
+        .filter(|finding| finding.severity == scene::ValidationSeverity::Error)
+        .take(8)
+        .map(|finding| {
+            format!(
+                "[{}] {}: {}",
+                finding.code, finding.source_path, finding.message
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    Err(format!(
+        "content validation failed {phase} with {} blocking error(s)\n{summary}",
+        validation.blocking_error_count()
+    ))
+}
+
+fn load_profile(project_root: &Path, profile_name: &str) -> Result<BuildProfile, String> {
+    if profile_name.is_empty()
+        || !profile_name
+            .chars()
+            .all(|character| character.is_ascii_alphanumeric() || matches!(character, '-' | '_'))
+    {
+        return Err("profile name must contain only letters, digits, '-' or '_'".into());
+    }
+    let path = project_root
+        .join("assets/build_profiles")
+        .join(format!("{profile_name}.ron"));
+    let text = fs::read_to_string(&path)
+        .map_err(|error| format!("could not read build profile {}: {error}", path.display()))?;
+    ron::from_str(&text)
+        .map_err(|error| format!("could not parse build profile {}: {error}", path.display()))
+}
+
+fn validate_profile(project_root: &Path, profile: &BuildProfile) -> Result<(), String> {
+    if profile.version != 1 {
+        return Err(format!(
+            "unsupported build profile version {}",
+            profile.version
+        ));
+    }
+    if profile.name.trim().is_empty() {
+        return Err("build profile name must not be empty".into());
+    }
+    if let Some(target) = &profile.target {
+        if target.trim().is_empty()
+            || !target.chars().all(|character| {
+                character.is_ascii_alphanumeric() || matches!(character, '-' | '_' | '.')
+            })
+        {
+            return Err(format!("invalid Rust target triple `{target}`"));
+        }
+        validate_supported_target(target)?;
+    }
+    if let Some(default_scene) = &profile.default_scene {
+        let path = resolve_project_asset(project_root, default_scene)
+            .ok_or_else(|| format!("default scene `{default_scene}` escapes the project"))?;
+        let relative = path
+            .strip_prefix(project_root.join("assets"))
+            .map_err(|_| format!("default scene `{default_scene}` is outside runtime assets"))?;
+        if !relative.starts_with("levels") || relative == Path::new("levels") {
+            return Err(format!(
+                "default scene `{default_scene}` must be under assets/levels/ so full project dependency validation covers it"
+            ));
+        }
+        let metadata = fs::symlink_metadata(&path).ok();
+        if !default_scene.ends_with(".scn.ron")
+            || !metadata.as_ref().is_some_and(fs::Metadata::is_file)
+        {
+            return Err(format!(
+                "default scene `{default_scene}` is missing or is not a .scn.ron scene"
+            ));
+        }
+        if metadata.is_some_and(|metadata| metadata.file_type().is_symlink())
+            || !include_runtime_asset(relative)
+        {
+            return Err(format!(
+                "default scene `{default_scene}` is not an included regular runtime asset"
+            ));
+        }
+        scene::validate_level_file(&path)
+            .map_err(|error| format!("default scene `{default_scene}` is invalid: {error}"))?;
+        scene::validate_composition_graph(&path, project_root).map_err(|error| {
+            format!("default scene `{default_scene}` has an invalid composition graph: {error}")
+        })?;
+    }
+    let mut features = BTreeSet::new();
+    for feature in &profile.features {
+        if feature.trim().is_empty()
+            || !feature.chars().all(|character| {
+                character.is_ascii_alphanumeric() || matches!(character, '-' | '_')
+            })
+        {
+            return Err(format!("invalid Cargo feature `{feature}`"));
+        }
+        if !features.insert(feature) {
+            return Err(format!("duplicate Cargo feature `{feature}`"));
+        }
+        if matches!(feature.as_str(), "dev" | "hot-reload") {
+            return Err(format!(
+                "Cargo feature `{feature}` uses runtime dynamic libraries and cannot be packaged"
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn validate_supported_target(target: &str) -> Result<(), String> {
+    let segments = target.split('-').collect::<Vec<_>>();
+    let is_windows = segments.contains(&"windows");
+    let is_desktop_linux = segments.contains(&"linux") && !segments.contains(&"android");
+    if is_windows || is_desktop_linux {
+        Ok(())
+    } else {
+        Err(format!(
+            "target `{target}` is not supported by the native package layout; use a desktop Linux or Windows target"
+        ))
+    }
+}
+
+fn build_game(project_root: &Path, profile: &BuildProfile) -> Result<BuiltArtifacts, String> {
+    let mut command = Command::new("cargo");
+    command.current_dir(project_root).args([
+        "build",
+        "-p",
+        "game",
+        "--profile",
+        profile.cargo_profile.cargo_name(),
+        "--message-format=json-render-diagnostics",
+    ]);
+    if let Some(target) = &profile.target {
+        command.args(["--target", target]);
+    }
+    if !profile.features.is_empty() {
+        command.args(["--features", &profile.features.join(",")]);
+    }
+    command.stdout(Stdio::piped());
+    let mut child = command
+        .spawn()
+        .map_err(|error| format!("could not start Cargo build: {error}"))?;
+    let stdout = child
+        .stdout
+        .take()
+        .ok_or_else(|| "Cargo build stdout was not captured".to_string())?;
+    let mut executable = None;
+    let mut companions = Vec::new();
+    let mut read_error = None;
+    for line in BufReader::new(stdout).lines() {
+        let line = match line {
+            Ok(line) => line,
+            Err(error) => {
+                read_error = Some(format!("could not read Cargo output: {error}"));
+                break;
+            }
+        };
+        let Ok(message) = serde_json::from_str::<serde_json::Value>(&line) else {
+            println!("{line}");
+            continue;
+        };
+        if let Some(rendered) = message
+            .get("message")
+            .and_then(|message| message.get("rendered"))
+            .and_then(serde_json::Value::as_str)
+        {
+            eprint!("{rendered}");
+        }
+        let is_game_binary = message.get("reason").and_then(serde_json::Value::as_str)
+            == Some("compiler-artifact")
+            && message
+                .get("target")
+                .and_then(|target| target.get("name"))
+                .and_then(serde_json::Value::as_str)
+                == Some("game")
+            && message
+                .get("target")
+                .and_then(|target| target.get("kind"))
+                .and_then(serde_json::Value::as_array)
+                .is_some_and(|kinds| kinds.iter().any(|kind| kind.as_str() == Some("bin")));
+        if is_game_binary {
+            executable = message
+                .get("executable")
+                .and_then(serde_json::Value::as_str)
+                .map(PathBuf::from);
+            companions = message
+                .get("filenames")
+                .and_then(serde_json::Value::as_array)
+                .into_iter()
+                .flatten()
+                .filter_map(serde_json::Value::as_str)
+                .map(PathBuf::from)
+                .collect();
+        }
+    }
+    if let Some(error) = read_error {
+        let _ = child.kill();
+        let _ = child.wait();
+        return Err(error);
+    }
+    let status = child
+        .wait()
+        .map_err(|error| format!("could not wait for Cargo build: {error}"))?;
+    if !status.success() {
+        return Err(format!("Cargo build failed with status {status}"));
+    }
+    let executable =
+        executable.ok_or("Cargo did not report the built `game` executable artifact")?;
+    companions.retain(|path| path != &executable);
+    companions.sort();
+    companions.dedup();
+    Ok(BuiltArtifacts {
+        executable,
+        companions,
+    })
+}
+
+fn select_debug_symbols(
+    profile: &BuildProfile,
+    effective_target: &str,
+    artifacts: &BuiltArtifacts,
+) -> Result<Option<(PathBuf, &'static str)>, String> {
+    if profile.cargo_profile != CargoProfile::Qa {
+        return Ok(None);
+    }
+    let pdb = artifacts.companions.iter().find(|path| {
+        path.extension()
+            .and_then(|extension| extension.to_str())
+            .is_some_and(|extension| extension.eq_ignore_ascii_case("pdb"))
+    });
+    if effective_target.contains("windows") && effective_target.contains("msvc") && pdb.is_none() {
+        return Err("Cargo did not report the PDB required by the Windows MSVC QA profile".into());
+    }
+    Ok(pdb.map(|path| (path.clone(), "blacksite.pdb")))
+}
+
+fn packaged_executable_name(effective_target: &str, artifact: &Path) -> &'static str {
+    if effective_target.contains("windows")
+        || artifact
+            .extension()
+            .and_then(|extension| extension.to_str())
+            == Some("exe")
+    {
+        "blacksite.exe"
+    } else {
+        "blacksite"
+    }
+}
+
+fn effective_build_target(engine_root: &Path, profile: &BuildProfile, artifact: &Path) -> String {
+    if let Some(target) = &profile.target {
+        return target.clone();
+    }
+    if let Some(target_directory) = cargo_target_directory(engine_root) {
+        let target_directory = target_directory.canonicalize().unwrap_or(target_directory);
+        let artifact = artifact
+            .canonicalize()
+            .unwrap_or_else(|_| artifact.to_path_buf());
+        if let Ok(relative) = artifact.strip_prefix(target_directory) {
+            let components = relative.components().collect::<Vec<_>>();
+            if let Some(profile_index) = components
+                .iter()
+                .position(|component| component.as_os_str() == profile.cargo_profile.cargo_name())
+            {
+                if profile_index > 0 {
+                    return components[profile_index - 1]
+                        .as_os_str()
+                        .to_string_lossy()
+                        .into_owned();
+                }
+            }
+        }
+    }
+    host_target(engine_root)
+}
+
+fn cargo_target_directory(engine_root: &Path) -> Option<PathBuf> {
+    let output = Command::new("cargo")
+        .current_dir(engine_root)
+        .args(["metadata", "--format-version=1", "--no-deps", "--offline"])
+        .output()
+        .ok()?
+        .stdout;
+    let metadata: serde_json::Value = serde_json::from_slice(&output).ok()?;
+    metadata
+        .get("target_directory")
+        .and_then(serde_json::Value::as_str)
+        .map(PathBuf::from)
+}
+
+fn engine_workspace_root() -> Result<PathBuf, String> {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .ok_or_else(|| "xtask must live under the engine workspace".to_string())?
+        .canonicalize()
+        .map_err(|error| format!("could not resolve engine workspace: {error}"))
+}
+
+fn resolve_output(project_root: &Path, output: &str) -> Result<PathBuf, String> {
+    let path = Path::new(output);
+    if path.as_os_str().is_empty()
+        || path == Path::new(".")
+        || path.is_absolute()
+        || path.components().any(|component| {
+            matches!(
+                component,
+                Component::CurDir
+                    | Component::ParentDir
+                    | Component::RootDir
+                    | Component::Prefix(_)
+            )
+        })
+    {
+        return Err("build output must be a project-relative path".into());
+    }
+    if !path.starts_with("dist") || path == Path::new("dist") {
+        return Err("build output must be inside a dedicated dist/<name> directory".into());
+    }
+    if ["assets", "target", ".git", ".cargo"]
+        .iter()
+        .any(|protected| path.starts_with(protected))
+    {
+        return Err("build output cannot be inside assets, target, .git, or .cargo".into());
+    }
+    let lexical_output = project_root.join(path);
+    let mut existing = lexical_output.as_path();
+    while fs::symlink_metadata(existing).is_err() {
+        existing = existing
+            .parent()
+            .ok_or_else(|| "build output has no project ancestor".to_string())?;
+    }
+    let root = project_root
+        .canonicalize()
+        .map_err(|error| format!("could not resolve project root: {error}"))?;
+    let dist = root.join("dist");
+    if fs::symlink_metadata(&dist)
+        .map(|metadata| metadata.file_type().is_symlink())
+        .unwrap_or(false)
+    {
+        return Err("project dist directory cannot be a symlink".into());
+    }
+    let resolved_dist = dist.canonicalize().unwrap_or(dist);
+    let resolved_ancestor = existing
+        .canonicalize()
+        .map_err(|error| format!("could not resolve build output ancestor: {error}"))?;
+    if !resolved_ancestor.starts_with(&root) {
+        return Err("build output escapes the project through a symlink".into());
+    }
+    let suffix = lexical_output
+        .strip_prefix(existing)
+        .map_err(|error| format!("could not resolve build output suffix: {error}"))?;
+    let resolved_output = resolved_ancestor.join(suffix);
+    if resolved_output == resolved_dist || !resolved_output.starts_with(&resolved_dist) {
+        return Err("build output must resolve inside the project dist directory".into());
+    }
+    for protected in ["assets", "target", ".git", ".cargo"] {
+        let protected = root.join(protected);
+        let protected = protected.canonicalize().unwrap_or(protected);
+        if resolved_output.starts_with(protected) {
+            return Err("build output cannot be inside assets, target, .git, or .cargo".into());
+        }
+    }
+    Ok(resolved_output)
+}
+
+const PACKAGE_LOCK_MAGIC: &str = "blacksite-package-lock";
+
+#[derive(Debug, Serialize, Deserialize)]
+struct PackageLockRecord {
+    magic: String,
+    schema_version: u32,
+    output: String,
+    pid: u32,
+}
+
+struct PackageLock {
+    file: fs::File,
+}
+
+impl PackageLock {
+    fn acquire(output: &Path) -> Result<Self, String> {
+        let parent = output
+            .parent()
+            .ok_or_else(|| "package output has no parent directory".to_string())?;
+        fs::create_dir_all(parent)
+            .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+        let stem = output
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("package");
+        let path = parent.join(format!(".blacksite-{stem}.lock"));
+        if fs::symlink_metadata(&path).is_ok_and(|metadata| metadata.file_type().is_symlink()) {
+            return Err(format!(
+                "refusing to open symlinked package lock {}",
+                path.display()
+            ));
+        }
+        let mut options = OpenOptions::new();
+        options.read(true).write(true).create(true);
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::OpenOptionsExt;
+            options.custom_flags(libc::O_NOFOLLOW);
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::OpenOptionsExt;
+            const FILE_FLAG_OPEN_REPARSE_POINT: u32 = 0x0020_0000;
+            options
+                .share_mode(0)
+                .custom_flags(FILE_FLAG_OPEN_REPARSE_POINT);
+        }
+        let mut file = options.open(&path).map_err(|error| {
+            format!(
+                "could not acquire package lock {} (another build may be active): {error}",
+                path.display()
+            )
+        })?;
+        if !file
+            .metadata()
+            .map_err(|error| format!("could not inspect package lock {}: {error}", path.display()))?
+            .is_file()
+        {
+            return Err(format!(
+                "package lock is not a regular file: {}",
+                path.display()
+            ));
+        }
+        lock_file_exclusive(&file).map_err(|error| {
+            format!(
+                "could not acquire package lock {} (another build may be active): {error}",
+                path.display()
+            )
+        })?;
+
+        let mut existing = String::new();
+        file.read_to_string(&mut existing)
+            .map_err(|error| format!("could not read package lock {}: {error}", path.display()))?;
+        let output_identity = output.to_string_lossy().into_owned();
+        if !existing.trim().is_empty() {
+            let record: PackageLockRecord = serde_json::from_str(&existing).map_err(|error| {
+                format!(
+                    "refusing to overwrite unrecognized package lock {}: {error}",
+                    path.display()
+                )
+            })?;
+            if record.magic != PACKAGE_LOCK_MAGIC
+                || record.schema_version != PACKAGE_SCHEMA_VERSION
+                || record.output != output_identity
+            {
+                return Err(format!(
+                    "refusing to overwrite unrecognized package lock {}",
+                    path.display()
+                ));
+            }
+        }
+        let record = PackageLockRecord {
+            magic: PACKAGE_LOCK_MAGIC.into(),
+            schema_version: PACKAGE_SCHEMA_VERSION,
+            output: output_identity,
+            pid: std::process::id(),
+        };
+        let mut encoded = serde_json::to_vec(&record)
+            .map_err(|error| format!("could not serialize package lock: {error}"))?;
+        encoded.push(b'\n');
+        let write_result = (|| -> std::io::Result<()> {
+            file.seek(std::io::SeekFrom::Start(0))?;
+            file.write_all(&encoded)?;
+            file.set_len(encoded.len() as u64)?;
+            file.sync_all()
+        })();
+        if let Err(error) = write_result {
+            let _ = file.seek(std::io::SeekFrom::Start(0));
+            let _ = file.write_all(existing.as_bytes());
+            let _ = file.set_len(existing.len() as u64);
+            let _ = file.sync_all();
+            return Err(format!(
+                "could not persist package lock {}: {error}",
+                path.display()
+            ));
+        }
+        Ok(Self { file })
+    }
+}
+
+impl Drop for PackageLock {
+    fn drop(&mut self) {
+        unlock_file(&self.file);
+    }
+}
+
+#[cfg(unix)]
+fn lock_file_exclusive(file: &fs::File) -> std::io::Result<()> {
+    use std::os::fd::AsRawFd;
+
+    let result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) };
+    (result == 0)
+        .then_some(())
+        .ok_or_else(std::io::Error::last_os_error)
+}
+
+#[cfg(windows)]
+fn lock_file_exclusive(_file: &fs::File) -> std::io::Result<()> {
+    // The zero-share-mode handle acquired above is the exclusive lock.
+    Ok(())
+}
+
+#[cfg(not(any(unix, windows)))]
+fn lock_file_exclusive(_file: &fs::File) -> std::io::Result<()> {
+    Err(std::io::Error::new(
+        std::io::ErrorKind::Unsupported,
+        "package locking is unsupported on this host",
+    ))
+}
+
+#[cfg(unix)]
+fn unlock_file(file: &fs::File) {
+    use std::os::fd::AsRawFd;
+
+    let _ = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_UN) };
+}
+
+#[cfg(not(unix))]
+fn unlock_file(_file: &fs::File) {}
+
+const PACKAGE_WORK_MAGIC: &str = "blacksite-package-staging";
+const PACKAGE_WORK_MARKER: &str = ".blacksite-package-work.json";
+
+#[derive(Debug, Serialize, Deserialize)]
+struct PackageWorkMarker {
+    magic: String,
+    schema_version: u32,
+    output: String,
+}
+
+fn write_work_marker(staging: &Path, output: &Path) -> Result<(), String> {
+    let marker = PackageWorkMarker {
+        magic: PACKAGE_WORK_MAGIC.into(),
+        schema_version: PACKAGE_SCHEMA_VERSION,
+        output: output.to_string_lossy().into_owned(),
+    };
+    let bytes = serde_json::to_vec(&marker)
+        .map_err(|error| format!("could not serialize staging ownership: {error}"))?;
+    write_file_atomically(&staging.join(PACKAGE_WORK_MARKER), &bytes)
+}
+
+fn verify_work_marker(staging: &Path, output: &Path) -> Result<(), String> {
+    let metadata = fs::symlink_metadata(staging).map_err(|error| {
+        format!(
+            "could not inspect interrupted staging path {}: {error}",
+            staging.display()
+        )
+    })?;
+    if !metadata.is_dir() || metadata.file_type().is_symlink() {
+        return Err(format!(
+            "refusing to remove unowned staging path {}",
+            staging.display()
+        ));
+    }
+    let marker_path = staging.join(PACKAGE_WORK_MARKER);
+    let marker_metadata = fs::symlink_metadata(&marker_path).map_err(|_| {
+        format!(
+            "refusing to remove unowned staging directory {}; ownership marker is missing",
+            staging.display()
+        )
+    })?;
+    if !marker_metadata.is_file() || marker_metadata.file_type().is_symlink() {
+        return Err(format!(
+            "refusing to remove staging directory with invalid ownership marker {}",
+            marker_path.display()
+        ));
+    }
+    let marker: PackageWorkMarker = serde_json::from_slice(
+        &fs::read(&marker_path)
+            .map_err(|error| format!("could not read {}: {error}", marker_path.display()))?,
+    )
+    .map_err(|error| format!("invalid staging ownership marker: {error}"))?;
+    if marker.magic != PACKAGE_WORK_MAGIC
+        || marker.schema_version != PACKAGE_SCHEMA_VERSION
+        || marker.output != output.to_string_lossy().as_ref()
+    {
+        return Err(format!(
+            "refusing to remove staging directory with unrecognized ownership marker {}",
+            marker_path.display()
+        ));
+    }
+    Ok(())
+}
+
+fn recover_interrupted_package(output: &Path) -> Result<(), String> {
+    let parent = output
+        .parent()
+        .ok_or_else(|| "package output has no parent directory".to_string())?;
+    let stem = output
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("package");
+    let prefix = format!(".blacksite-{stem}-");
+    let mut staging = Vec::new();
+    let mut backups = Vec::new();
+    for entry in fs::read_dir(parent)
+        .map_err(|error| format!("could not inspect {}: {error}", parent.display()))?
+    {
+        let entry =
+            entry.map_err(|error| format!("could not inspect package work directory: {error}"))?;
+        let name = entry.file_name();
+        let name = name.to_string_lossy();
+        if !name.starts_with(&prefix) {
+            continue;
+        }
+        match entry
+            .path()
+            .extension()
+            .and_then(|extension| extension.to_str())
+        {
+            Some("staging") => staging.push(entry.path()),
+            Some("backup") => backups.push(entry.path()),
+            _ => {}
+        }
+    }
+    for path in staging {
+        verify_work_marker(&path, output)?;
+        remove_path(&path)?;
+        eprintln!(
+            "package-project: removed interrupted staging directory {}",
+            path.display()
+        );
+    }
+
+    let output_is_empty = output.is_dir()
+        && fs::read_dir(output)
+            .map_err(|error| format!("could not inspect {}: {error}", output.display()))?
+            .next()
+            .is_none();
+    if output_is_empty {
+        fs::remove_dir(output)
+            .map_err(|error| format!("could not remove empty {}: {error}", output.display()))?;
+    }
+    backups.sort_by_key(|path| {
+        std::cmp::Reverse(
+            fs::metadata(path)
+                .and_then(|metadata| metadata.modified())
+                .unwrap_or(UNIX_EPOCH),
+        )
+    });
+    if !output.exists() {
+        if let Some(backup) = backups.first() {
+            verify_strict_owned_package(backup)?;
+            fs::rename(backup, output).map_err(|error| {
+                format!(
+                    "could not restore interrupted package backup {} to {}: {error}",
+                    backup.display(),
+                    output.display()
+                )
+            })?;
+            eprintln!(
+                "package-project: restored previous package from {}",
+                backup.display()
+            );
+        }
+    } else {
+        verify_owned_output(output)?;
+    }
+    let published_marker = output.join(PACKAGE_WORK_MARKER);
+    if published_marker.exists() {
+        verify_work_marker(output, output)?;
+        fs::remove_file(&published_marker).map_err(|error| {
+            format!(
+                "could not remove recovered staging marker {}: {error}",
+                published_marker.display()
+            )
+        })?;
+    }
+    for backup in backups {
+        if backup.exists() {
+            verify_strict_owned_package(&backup)?;
+            remove_path(&backup)?;
+        }
+    }
+    Ok(())
+}
+
+struct PendingPackage {
+    path: PathBuf,
+    published: bool,
+}
+
+impl PendingPackage {
+    fn new(output: &Path) -> Result<Self, String> {
+        if output.exists() && !output.is_dir() {
+            return Err(format!(
+                "package output exists but is not a directory: {}",
+                output.display()
+            ));
+        }
+        verify_owned_output(output)?;
+        let parent = output
+            .parent()
+            .ok_or_else(|| "package output has no parent directory".to_string())?;
+        fs::create_dir_all(parent)
+            .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+        let stem = output
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("package");
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos();
+        for attempt in 0..100_u32 {
+            let path = parent.join(format!(
+                ".blacksite-{stem}-{}-{nonce}-{attempt}.staging",
+                std::process::id()
+            ));
+            match fs::create_dir(&path) {
+                Ok(()) => {
+                    if let Err(error) = write_work_marker(&path, output) {
+                        let _ = fs::remove_dir_all(&path);
+                        return Err(error);
+                    }
+                    return Ok(Self {
+                        path,
+                        published: false,
+                    });
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
+                Err(error) => {
+                    return Err(format!(
+                        "could not create package staging directory {}: {error}",
+                        path.display()
+                    ));
+                }
+            }
+        }
+        Err("could not reserve a unique package staging directory".into())
+    }
+
+    fn path(&self) -> &Path {
+        &self.path
+    }
+
+    fn seed_from(&self, output: &Path) -> Result<(), String> {
+        if output.is_dir() {
+            seed_directory(output, &self.path)?;
+        }
+        Ok(())
+    }
+
+    fn publish(&mut self, output: &Path) -> Result<(), String> {
+        let backup = self.path.with_extension("backup");
+        if fs::symlink_metadata(&backup).is_ok() {
+            return Err(format!(
+                "reserved package backup path already exists: {}",
+                backup.display()
+            ));
+        }
+        let had_previous = output.exists();
+        if had_previous {
+            fs::rename(output, &backup).map_err(|error| {
+                format!(
+                    "could not move previous package {} aside: {error}",
+                    output.display()
+                )
+            })?;
+        }
+        if let Err(error) = fs::rename(&self.path, output) {
+            if had_previous {
+                if let Err(restore_error) = fs::rename(&backup, output) {
+                    return Err(format!(
+                        "could not promote staged package to {}; restoring the previous package also failed: {restore_error}. The previous package remains at {} (promotion error: {error})",
+                        output.display(),
+                        backup.display()
+                    ));
+                }
+            }
+            return Err(format!(
+                "could not promote staged package to {}: {error}",
+                output.display()
+            ));
+        }
+        self.published = true;
+        let published_marker = output.join(PACKAGE_WORK_MARKER);
+        if let Err(error) = fs::remove_file(&published_marker) {
+            eprintln!(
+                "package-project: warning: could not remove staging marker {}: {error}",
+                published_marker.display()
+            );
+        }
+        if had_previous {
+            if let Err(error) = remove_path(&backup) {
+                eprintln!(
+                    "package-project: warning: could not remove old package backup {}: {error}",
+                    backup.display()
+                );
+            }
+        }
+        Ok(())
+    }
+}
+
+fn verify_owned_output(output: &Path) -> Result<(), String> {
+    verify_owned_output_inner(output, true)
+}
+
+fn verify_strict_owned_package(output: &Path) -> Result<(), String> {
+    verify_owned_output_inner(output, false)
+}
+
+fn verify_owned_output_inner(output: &Path, allow_missing_or_empty: bool) -> Result<(), String> {
+    let output_metadata = match fs::symlink_metadata(output) {
+        Ok(metadata) => metadata,
+        Err(error) if allow_missing_or_empty && error.kind() == std::io::ErrorKind::NotFound => {
+            return Ok(());
+        }
+        Err(error) => {
+            return Err(format!(
+                "could not inspect package output {}: {error}",
+                output.display()
+            ));
+        }
+    };
+    if !output_metadata.is_dir() || output_metadata.file_type().is_symlink() {
+        return Err(format!(
+            "package output is not a regular directory: {}",
+            output.display()
+        ));
+    }
+    let mut entries = fs::read_dir(output)
+        .map_err(|error| format!("could not inspect {}: {error}", output.display()))?;
+    if entries.next().is_none() {
+        return if allow_missing_or_empty {
+            Ok(())
+        } else {
+            Err(format!(
+                "package backup is empty and has no ownership metadata: {}",
+                output.display()
+            ))
+        };
+    }
+    let metadata_path = output.join("build-metadata.json");
+    let metadata_file = fs::symlink_metadata(&metadata_path).map_err(|_| {
+        format!(
+            "refusing to replace non-empty unowned output {}; build-metadata.json is missing",
+            output.display()
+        )
+    })?;
+    if !metadata_file.is_file() || metadata_file.file_type().is_symlink() {
+        return Err(format!(
+            "package ownership metadata is not a regular file: {}",
+            metadata_path.display()
+        ));
+    }
+    let text = fs::read_to_string(&metadata_path).map_err(|_| {
+        format!(
+            "refusing to replace non-empty unowned output {}; build-metadata.json is missing",
+            output.display()
+        )
+    })?;
+    let metadata: serde_json::Value = serde_json::from_str(&text).map_err(|error| {
+        format!(
+            "refusing to replace output with invalid ownership metadata {}: {error}",
+            metadata_path.display()
+        )
+    })?;
+    let schema_matches = metadata
+        .get("schema_version")
+        .and_then(serde_json::Value::as_u64)
+        == Some(u64::from(PACKAGE_SCHEMA_VERSION));
+    let executable_matches = matches!(
+        metadata
+            .get("executable")
+            .and_then(serde_json::Value::as_str),
+        Some("blacksite" | "blacksite.exe")
+    );
+    if !schema_matches || !executable_matches {
+        return Err(format!(
+            "refusing to replace output with unrecognized ownership metadata {}",
+            metadata_path.display()
+        ));
+    }
+    let executable = output.join(
+        metadata
+            .get("executable")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or_default(),
+    );
+    let executable_metadata = fs::symlink_metadata(&executable).map_err(|_| {
+        format!(
+            "owned package executable is missing at {}",
+            executable.display()
+        )
+    })?;
+    if !executable_metadata.is_file() || executable_metadata.file_type().is_symlink() {
+        return Err(format!(
+            "owned package executable is not a regular file: {}",
+            executable.display()
+        ));
+    }
+    Ok(())
+}
+
+impl Drop for PendingPackage {
+    fn drop(&mut self) {
+        if !self.published && fs::symlink_metadata(&self.path).is_ok() {
+            let _ = remove_path(&self.path);
+        }
+    }
+}
+
+fn seed_directory(source: &Path, destination: &Path) -> Result<(), String> {
+    for entry in WalkDir::new(source).follow_links(false) {
+        let entry =
+            entry.map_err(|error| format!("could not inspect previous package: {error}"))?;
+        let relative = entry
+            .path()
+            .strip_prefix(source)
+            .map_err(|error| format!("could not relativize previous package: {error}"))?;
+        if relative.as_os_str().is_empty() {
+            continue;
+        }
+        let target = destination.join(relative);
+        if entry.file_type().is_symlink() {
+            return Err(format!(
+                "previous package contains unsupported symlink: {}",
+                entry.path().display()
+            ));
+        }
+        if entry.file_type().is_dir() {
+            fs::create_dir_all(&target)
+                .map_err(|error| format!("could not create {}: {error}", target.display()))?;
+        } else if entry.file_type().is_file() {
+            if let Some(parent) = target.parent() {
+                fs::create_dir_all(parent)
+                    .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+            }
+            fs::copy(entry.path(), &target).map_err(|error| {
+                format!(
+                    "could not seed {} from previous package: {error}",
+                    target.display()
+                )
+            })?;
+        } else {
+            return Err(format!(
+                "previous package contains unsupported filesystem entry: {}",
+                entry.path().display()
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn prune_package_root(
+    staging: &Path,
+    executable_name: &str,
+    debug_symbols: Option<&str>,
+    stats: &mut CopyStats,
+) -> Result<(), String> {
+    let entries = fs::read_dir(staging)
+        .map_err(|error| format!("could not inspect staged package: {error}"))?;
+    for entry in entries {
+        let entry = entry.map_err(|error| format!("could not inspect staged package: {error}"))?;
+        let name = entry.file_name();
+        if name == "assets"
+            || name == executable_name
+            || name == "build-metadata.json"
+            || name == PACKAGE_WORK_MARKER
+            || debug_symbols.is_some_and(|debug_symbols| name == debug_symbols)
+        {
+            continue;
+        }
+        remove_path(&entry.path())?;
+        stats.pruned += 1;
+    }
+    Ok(())
+}
+
+fn remove_path(path: &Path) -> Result<(), String> {
+    let metadata = fs::symlink_metadata(path)
+        .map_err(|error| format!("could not inspect {}: {error}", path.display()))?;
+    if metadata.file_type().is_symlink() {
+        return Err(format!(
+            "refusing to remove unsupported symlink {}",
+            path.display()
+        ));
+    }
+    make_owned_path_writable(path)?;
+    if metadata.is_dir() {
+        fs::remove_dir_all(path)
+    } else {
+        fs::remove_file(path)
+    }
+    .map_err(|error| format!("could not remove {}: {error}", path.display()))
+}
+
+#[cfg(windows)]
+fn make_owned_path_writable(path: &Path) -> Result<(), String> {
+    for entry in WalkDir::new(path).follow_links(false) {
+        let entry = entry.map_err(|error| format!("could not inspect owned path: {error}"))?;
+        if entry.file_type().is_symlink() {
+            return Err(format!(
+                "owned package path contains unsupported symlink: {}",
+                entry.path().display()
+            ));
+        }
+        let mut permissions = entry
+            .metadata()
+            .map_err(|error| format!("could not inspect {}: {error}", entry.path().display()))?
+            .permissions();
+        if permissions.readonly() {
+            permissions.set_readonly(false);
+            fs::set_permissions(entry.path(), permissions).map_err(|error| {
+                format!(
+                    "could not make {} writable: {error}",
+                    entry.path().display()
+                )
+            })?;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(not(windows))]
+fn make_owned_path_writable(_path: &Path) -> Result<(), String> {
+    Ok(())
+}
+
+fn package_assets(
+    project_root: &Path,
+    output: &Path,
+    default_scene: Option<&str>,
+    rendering_tier: RenderingTier,
+    stats: &mut CopyStats,
+) -> Result<(Vec<ContentEntry>, Vec<ContentEntry>), String> {
+    let mut content = Vec::new();
+    let mut source_fingerprint = Vec::new();
+    let sources = runtime_asset_sources(project_root)?;
+    let desired = sources
+        .iter()
+        .map(|(relative, _)| relative.clone())
+        .collect::<BTreeSet<_>>();
+    prune_stale_asset_files(output, &desired, stats)?;
+    for (relative, source) in sources {
+        let relative = relative.as_path();
+        let destination = output.join(relative);
+        let source_bytes = fs::read(&source)
+            .map_err(|error| format!("could not read {}: {error}", source.display()))?;
+        source_fingerprint.push(content_entry_bytes(
+            &source_bytes,
+            &relative.to_string_lossy().replace('\\', "/"),
+        ));
+        let packaged_bytes = if relative == Path::new("project.ron") {
+            packaged_project_settings(&source_bytes, default_scene, rendering_tier)?
+        } else {
+            source_bytes
+        };
+        copy_bytes_if_changed(&source, &destination, &packaged_bytes, stats)?;
+        content.push(content_entry_bytes(
+            &packaged_bytes,
+            &format!("assets/{}", relative.to_string_lossy().replace('\\', "/")),
+        ));
+    }
+    prune_empty_asset_directories(output)?;
+    content.sort_by(|left, right| left.path.cmp(&right.path));
+    source_fingerprint.sort_by(|left, right| left.path.cmp(&right.path));
+    Ok((content, source_fingerprint))
+}
+
+fn prune_stale_asset_files(
+    output: &Path,
+    desired: &BTreeSet<PathBuf>,
+    stats: &mut CopyStats,
+) -> Result<(), String> {
+    if !output.exists() {
+        return Ok(());
+    }
+    let mut stale = WalkDir::new(output)
+        .follow_links(false)
+        .into_iter()
+        .map(|entry| entry.map_err(|error| format!("could not inspect staged assets: {error}")))
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .filter(|entry| entry.file_type().is_file())
+        .filter_map(|entry| {
+            let relative = entry.path().strip_prefix(output).ok()?;
+            (!desired.contains(relative)).then(|| entry.path().to_path_buf())
+        })
+        .collect::<Vec<_>>();
+    stale.sort();
+    for path in stale {
+        remove_path(&path)?;
+        stats.pruned += 1;
+    }
+    Ok(())
+}
+
+fn prune_empty_asset_directories(output: &Path) -> Result<(), String> {
+    if !output.exists() {
+        return Ok(());
+    }
+    let mut directories = WalkDir::new(output)
+        .min_depth(1)
+        .follow_links(false)
+        .into_iter()
+        .map(|entry| entry.map_err(|error| format!("could not inspect staged assets: {error}")))
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .filter(|entry| entry.file_type().is_dir())
+        .map(|entry| entry.into_path())
+        .collect::<Vec<_>>();
+    directories.sort_by_key(|path| std::cmp::Reverse(path.components().count()));
+    for directory in directories {
+        let is_empty = fs::read_dir(&directory)
+            .map_err(|error| format!("could not inspect {}: {error}", directory.display()))?
+            .next()
+            .is_none();
+        if is_empty {
+            make_owned_path_writable(&directory)?;
+            fs::remove_dir(&directory)
+                .map_err(|error| format!("could not prune {}: {error}", directory.display()))?;
+        }
+    }
+    Ok(())
+}
+
+fn runtime_asset_sources(project_root: &Path) -> Result<Vec<(PathBuf, PathBuf)>, String> {
+    let assets = project_root.join("assets");
+    let mut sources = Vec::new();
+    let walker = WalkDir::new(&assets)
+        .follow_links(false)
+        .into_iter()
+        .filter_entry(|entry| {
+            entry
+                .path()
+                .strip_prefix(&assets)
+                .map(|relative| {
+                    relative.as_os_str().is_empty() || !is_excluded_runtime_path(relative)
+                })
+                .unwrap_or(true)
+        });
+    for entry in walker {
+        let entry = entry.map_err(|error| format!("could not walk runtime assets: {error}"))?;
+        let relative = entry
+            .path()
+            .strip_prefix(&assets)
+            .map_err(|error| format!("could not relativize asset path: {error}"))?;
+        if entry.file_type().is_symlink() && include_runtime_asset(relative) {
+            return Err(format!(
+                "runtime asset symlinks are not supported: assets/{}",
+                relative.display()
+            ));
+        }
+        if entry.file_type().is_file() && include_runtime_asset(relative) {
+            sources.push((relative.to_path_buf(), entry.path().to_path_buf()));
+        }
+    }
+    sources.sort_by(|left, right| left.0.cmp(&right.0));
+    Ok(sources)
+}
+
+fn fingerprint_runtime_assets(project_root: &Path) -> Result<Vec<ContentEntry>, String> {
+    runtime_asset_sources(project_root)?
+        .into_iter()
+        .map(|(relative, source)| {
+            let bytes = fs::read(&source)
+                .map_err(|error| format!("could not read {}: {error}", source.display()))?;
+            Ok(content_entry_bytes(
+                &bytes,
+                &relative.to_string_lossy().replace('\\', "/"),
+            ))
+        })
+        .collect()
+}
+
+fn include_runtime_asset(relative: &Path) -> bool {
+    scene::is_runtime_package_asset(relative)
+}
+
+fn is_excluded_runtime_path(relative: &Path) -> bool {
+    scene::is_runtime_package_excluded_tree(relative)
+}
+
+fn copy_if_changed(source: &Path, destination: &Path, stats: &mut CopyStats) -> Result<(), String> {
+    let source_bytes = fs::read(source)
+        .map_err(|error| format!("could not read {}: {error}", source.display()))?;
+    copy_bytes_if_changed(source, destination, &source_bytes, stats)
+}
+
+fn copy_bytes_if_changed(
+    source: &Path,
+    destination: &Path,
+    source_bytes: &[u8],
+    stats: &mut CopyStats,
+) -> Result<(), String> {
+    if fs::read(destination).ok().as_deref() == Some(source_bytes)
+        && permissions_match(source, destination)?
+    {
+        stats.reused += 1;
+        return Ok(());
+    }
+    if let Some(parent) = destination.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+    }
+    if fs::symlink_metadata(destination).is_ok() {
+        remove_path(destination)?;
+    }
+    fs::write(destination, source_bytes)
+        .map_err(|error| format!("could not write {}: {error}", destination.display()))?;
+    copy_permissions(source, destination)?;
+    stats.written += 1;
+    Ok(())
+}
+
+fn permissions_match(source: &Path, destination: &Path) -> Result<bool, String> {
+    let source = fs::metadata(source)
+        .map_err(|error| format!("could not inspect {}: {error}", source.display()))?;
+    let destination = fs::metadata(destination)
+        .map_err(|error| format!("could not inspect {}: {error}", destination.display()))?;
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        Ok(source.permissions().mode() == destination.permissions().mode())
+    }
+    #[cfg(not(unix))]
+    {
+        Ok(source.permissions().readonly() == destination.permissions().readonly())
+    }
+}
+
+fn copy_permissions(source: &Path, destination: &Path) -> Result<(), String> {
+    let permissions = fs::metadata(source)
+        .map_err(|error| format!("could not inspect {}: {error}", source.display()))?
+        .permissions();
+    fs::set_permissions(destination, permissions).map_err(|error| {
+        format!(
+            "could not set permissions on {}: {error}",
+            destination.display()
+        )
+    })
+}
+
+fn content_entry(path: &Path, display_path: &str) -> Result<ContentEntry, String> {
+    let bytes =
+        fs::read(path).map_err(|error| format!("could not hash {}: {error}", path.display()))?;
+    Ok(content_entry_bytes(&bytes, display_path))
+}
+
+fn content_entry_bytes(bytes: &[u8], display_path: &str) -> ContentEntry {
+    ContentEntry {
+        path: display_path.to_string(),
+        byte_len: bytes.len() as u64,
+        blake3: blake3::hash(bytes).to_hex().to_string(),
+    }
+}
+
+fn verify_staged_content(staging: &Path, expected: &[ContentEntry]) -> Result<(), String> {
+    let expected_paths = expected
+        .iter()
+        .map(|entry| entry.path.as_str())
+        .collect::<BTreeSet<_>>();
+    for entry in expected {
+        let relative = Path::new(&entry.path);
+        if relative.is_absolute()
+            || relative.components().any(|component| {
+                matches!(
+                    component,
+                    Component::ParentDir | Component::RootDir | Component::Prefix(_)
+                )
+            })
+        {
+            return Err(format!("invalid staged content path `{}`", entry.path));
+        }
+        let path = staging.join(relative);
+        let metadata = fs::symlink_metadata(&path)
+            .map_err(|error| format!("staged content is missing at {}: {error}", path.display()))?;
+        if !metadata.is_file() || metadata.file_type().is_symlink() {
+            return Err(format!(
+                "staged content is not a regular file: {}",
+                path.display()
+            ));
+        }
+        let actual = content_entry(&path, &entry.path)?;
+        if &actual != entry {
+            return Err(format!(
+                "staged content changed after assembly: {}",
+                path.display()
+            ));
+        }
+    }
+    for entry in WalkDir::new(staging).follow_links(false) {
+        let entry = entry.map_err(|error| format!("could not verify staged package: {error}"))?;
+        if entry.file_type().is_symlink() {
+            return Err(format!(
+                "staged package contains unsupported symlink: {}",
+                entry.path().display()
+            ));
+        }
+        if !entry.file_type().is_file() {
+            continue;
+        }
+        let relative = entry
+            .path()
+            .strip_prefix(staging)
+            .map_err(|error| format!("could not relativize staged content: {error}"))?;
+        let normalized = relative.to_string_lossy().replace('\\', "/");
+        if normalized == PACKAGE_WORK_MARKER || normalized == "build-metadata.json" {
+            continue;
+        }
+        if !expected_paths.contains(normalized.as_str()) {
+            return Err(format!(
+                "staged package contains untracked file: {}",
+                entry.path().display()
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn packaged_project_settings(
+    bytes: &[u8],
+    default_scene: Option<&str>,
+    rendering_tier: RenderingTier,
+) -> Result<Vec<u8>, String> {
+    let text = std::str::from_utf8(bytes)
+        .map_err(|error| format!("project settings are not UTF-8: {error}"))?;
+    let mut settings: settings::ProjectSettings = ron::from_str(text)
+        .map_err(|error| format!("could not parse project settings for packaging: {error}"))?;
+    if let Some(default_scene) = default_scene {
+        settings.default_level = default_scene.to_string();
+    }
+    if rendering_tier == RenderingTier::Development {
+        settings.rendering.gi_mode = settings::GiMode::Forward;
+    }
+    ron::ser::to_string_pretty(&settings, ron::ser::PrettyConfig::default())
+        .map(String::into_bytes)
+        .map_err(|error| format!("could not serialize packaged project settings: {error}"))
+}
+
+fn write_file_atomically(path: &Path, bytes: &[u8]) -> Result<(), String> {
+    let parent = path
+        .parent()
+        .ok_or_else(|| format!("{} has no parent directory", path.display()))?;
+    fs::create_dir_all(parent)
+        .map_err(|error| format!("could not create {}: {error}", parent.display()))?;
+    let temporary = parent.join(format!(
+        ".{}-{}.tmp",
+        path.file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("package"),
+        std::process::id()
+    ));
+    fs::write(&temporary, bytes)
+        .map_err(|error| format!("could not write {}: {error}", temporary.display()))?;
+    if fs::symlink_metadata(path).is_ok() {
+        remove_path(path)?;
+    }
+    fs::rename(&temporary, path).map_err(|error| {
+        let _ = fs::remove_file(&temporary);
+        format!("could not publish {}: {error}", path.display())
+    })
+}
+
+fn resolve_project_asset(project_root: &Path, reference: &str) -> Option<PathBuf> {
+    let relative = Path::new(reference);
+    if relative.is_absolute()
+        || relative.components().any(|component| {
+            matches!(
+                component,
+                Component::ParentDir | Component::RootDir | Component::Prefix(_)
+            )
+        })
+    {
+        return None;
+    }
+    let candidate = if relative.starts_with("assets") {
+        project_root.join(relative)
+    } else {
+        project_root.join("assets").join(relative)
+    };
+    let root = project_root.canonicalize().ok()?;
+    let mut existing = candidate.as_path();
+    while !existing.exists() {
+        existing = existing.parent()?;
+    }
+    existing
+        .canonicalize()
+        .ok()
+        .filter(|resolved| resolved.starts_with(root))?;
+    Some(candidate)
+}
+
+fn host_target(project_root: &Path) -> String {
+    command_output(project_root, "rustc", &["-vV"])
+        .lines()
+        .find_map(|line| line.strip_prefix("host: "))
+        .unwrap_or("unknown")
+        .to_string()
+}
+
+fn command_output(project_root: &Path, program: &str, args: &[&str]) -> String {
+    command_output_optional(project_root, program, args).unwrap_or_else(|| "unavailable".into())
+}
+
+fn command_output_optional(project_root: &Path, program: &str, args: &[&str]) -> Option<String> {
+    Command::new(program)
+        .current_dir(project_root)
+        .args(args)
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .map(|output| String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static NEXT_FIXTURE: AtomicU64 = AtomicU64::new(1);
+
+    fn fixture_root() -> PathBuf {
+        let root = std::env::temp_dir().join(format!(
+            "blacksite-package-project-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        fs::create_dir_all(root.join("assets/levels")).unwrap();
+        fs::create_dir_all(root.join("assets/.index")).unwrap();
+        fs::create_dir_all(root.join("assets/build_profiles")).unwrap();
+        fs::write(root.join("assets/.index/registry.ron"), "[]").unwrap();
+        fs::write(
+            root.join("assets/project.ron"),
+            "(version:1,template_version:1,default_level:\"assets/levels/main.scn.ron\",asset_roots:[\"assets/levels\"],capabilities:[])",
+        )
+        .unwrap();
+        fs::write(
+            root.join("assets/build_profiles/release.ron"),
+            "(version:1,name:\"Release\",cargo_profile:Release,target:None,features:[],rendering_tier:\"shipping\",default_scene:None,output_dir:\"dist/release\")",
+        )
+        .unwrap();
+        root
+    }
+
+    fn mark_owned_output(output: &Path) {
+        if !output.join("blacksite").exists() {
+            fs::write(output.join("blacksite"), b"fixture executable").unwrap();
+        }
+        fs::write(
+            output.join("build-metadata.json"),
+            r#"{"schema_version":1,"executable":"blacksite"}"#,
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn runtime_asset_filter_excludes_editor_and_source_files() {
+        for excluded in [
+            ".index/registry.ron",
+            ".trash/deleted.png",
+            "thumbnails/a.png",
+            "build_profiles/release.ron",
+            "levels/recovery/a.scn.ron",
+            "models/source.blend",
+            "textures/a.psd",
+            "levels/a.scn.ron.bak",
+        ] {
+            assert!(!include_runtime_asset(Path::new(excluded)), "{excluded}");
+        }
+        for included in [
+            "project.ron",
+            "levels/main.scn.ron",
+            "models/mesh.glb",
+            "textures/albedo.png",
+            "meshes/generated/id.static_mesh.ron",
+        ] {
+            assert!(include_runtime_asset(Path::new(included)), "{included}");
+        }
+    }
+
+    #[test]
+    fn unchanged_copy_is_reused() {
+        let root =
+            std::env::temp_dir().join(format!("blacksite-package-copy-{}", std::process::id()));
+        fs::create_dir_all(&root).unwrap();
+        let source = root.join("source");
+        let destination = root.join("destination");
+        fs::write(&source, b"same").unwrap();
+        let mut stats = CopyStats::default();
+        copy_if_changed(&source, &destination, &mut stats).unwrap();
+        copy_if_changed(&source, &destination, &mut stats).unwrap();
+        assert_eq!(
+            stats,
+            CopyStats {
+                written: 1,
+                reused: 1,
+                pruned: 0,
+            }
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn staged_assets_support_file_directory_shape_changes() {
+        let root = fixture_root();
+        let output = root.join("staged-assets");
+        fs::create_dir_all(&output).unwrap();
+        fs::write(output.join("changed"), b"old file").unwrap();
+        let desired = BTreeSet::from([PathBuf::from("changed/child.bin")]);
+        let mut stats = CopyStats::default();
+
+        prune_stale_asset_files(&output, &desired, &mut stats).unwrap();
+        let source = root.join("child.bin");
+        fs::write(&source, b"new child").unwrap();
+        copy_if_changed(&source, &output.join("changed/child.bin"), &mut stats).unwrap();
+
+        assert_eq!(
+            fs::read(output.join("changed/child.bin")).unwrap(),
+            b"new child"
+        );
+        assert_eq!(stats.pruned, 1);
+
+        let replacement = root.join("replacement.bin");
+        fs::write(&replacement, b"replacement").unwrap();
+        copy_if_changed(&replacement, &output.join("changed"), &mut stats).unwrap();
+        assert_eq!(fs::read(output.join("changed")).unwrap(), b"replacement");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn staged_content_verification_detects_tampering_and_untracked_files() {
+        let root = fixture_root();
+        let staging = root.join("staging");
+        fs::create_dir_all(&staging).unwrap();
+        let file = staging.join("blacksite");
+        fs::write(&file, b"expected").unwrap();
+        let expected = vec![content_entry(&file, "blacksite").unwrap()];
+        verify_staged_content(&staging, &expected).unwrap();
+
+        fs::write(&file, b"changed").unwrap();
+        assert!(verify_staged_content(&staging, &expected)
+            .unwrap_err()
+            .contains("changed after assembly"));
+        fs::write(&file, b"expected").unwrap();
+        fs::write(staging.join("unexpected.dll"), b"unexpected").unwrap();
+        assert!(verify_staged_content(&staging, &expected)
+            .unwrap_err()
+            .contains("untracked file"));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn blocking_content_error_refuses_packaging_before_binary_lookup() {
+        let root = fixture_root();
+        fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            r#"(schema_version:2,resources:{},entities:{1:(components:{
+                "shared::components::ActorId":("missing-model-owner"),
+                "shared::components::ModelRef":(path:"models/missing.glb",scene_index:0),
+            })})"#,
+        )
+        .unwrap();
+        let error = run(Options {
+            project_root: root.clone(),
+            profile_name: "release".into(),
+            skip_build: true,
+            artifact: None,
+        })
+        .unwrap_err();
+        assert!(error.contains("content validation failed"), "{error}");
+        assert!(error.contains("assets/levels/main.scn.ron"), "{error}");
+        assert!(error.contains("missing.glb"), "{error}");
+        assert!(!root.join("dist/release").exists());
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn package_output_cannot_escape_through_symlink() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let outside = std::env::temp_dir().join(format!(
+            "blacksite-package-outside-{}-{}",
+            std::process::id(),
+            NEXT_FIXTURE.fetch_add(1, Ordering::Relaxed)
+        ));
+        fs::create_dir_all(&outside).unwrap();
+        fs::create_dir_all(root.join("dist")).unwrap();
+        symlink(&outside, root.join("dist/escape")).unwrap();
+        let error = resolve_output(&root, "dist/escape/release").unwrap_err();
+        assert!(error.contains("symlink"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+        fs::remove_dir_all(outside).unwrap();
+    }
+
+    #[test]
+    fn package_output_rejects_source_and_build_trees() {
+        let root = fixture_root();
+        for output in [
+            ".",
+            "./assets/export",
+            "assets/export",
+            "target/export",
+            ".git/export",
+            "docs/export",
+            "crates/export",
+            "dist",
+        ] {
+            assert!(resolve_output(&root, output).is_err(), "{output}");
+        }
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn package_output_rejects_symlink_alias_to_assets() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        fs::create_dir_all(root.join("dist")).unwrap();
+        symlink(root.join("assets"), root.join("dist/assets-link")).unwrap();
+        let error = resolve_output(&root, "dist/assets-link/export").unwrap_err();
+        assert!(error.contains("project dist directory"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn build_profile_rejects_unsafe_target_triple() {
+        let root = fixture_root();
+        fs::write(
+            root.join("assets/levels/main.scn.ron"),
+            "(schema_version:2,resources:{},entities:{})",
+        )
+        .unwrap();
+        let profile: BuildProfile = ron::from_str(
+            "(version:1,name:\"Bad\",cargo_profile:Release,target:Some(\"../../tmp\"),features:[],rendering_tier:\"shipping\",default_scene:Some(\"assets/levels/main.scn.ron\"),output_dir:\"dist/release\")",
+        )
+        .unwrap();
+        assert!(validate_profile(&root, &profile)
+            .unwrap_err()
+            .contains("target triple"));
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn build_profile_rejects_unsupported_platform_bundle() {
+        let root = fixture_root();
+        let profile: BuildProfile = ron::from_str(
+            "(version:1,name:\"Web\",cargo_profile:Release,target:Some(\"wasm32-unknown-unknown\"),features:[],rendering_tier:\"shipping\",default_scene:None,output_dir:\"dist/web\")",
+        )
+        .unwrap();
+        let error = validate_profile(&root, &profile).unwrap_err();
+        assert!(error.contains("native package layout"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn windows_msvc_qa_requires_and_selects_the_cargo_pdb() {
+        let root = fixture_root();
+        let executable = root.join("game.exe");
+        let pdb = root.join("game.pdb");
+        fs::write(&executable, b"exe").unwrap();
+        fs::write(&pdb, b"symbols").unwrap();
+        let profile: BuildProfile = ron::from_str(
+            "(version:1,name:\"QA\",cargo_profile:Qa,target:Some(\"x86_64-pc-windows-msvc\"),features:[],rendering_tier:\"representative\",default_scene:None,output_dir:\"dist/qa\")",
+        )
+        .unwrap();
+        let with_symbols = BuiltArtifacts {
+            executable: executable.clone(),
+            companions: vec![pdb.clone()],
+        };
+        assert_eq!(
+            select_debug_symbols(&profile, "x86_64-pc-windows-msvc", &with_symbols).unwrap(),
+            Some((pdb, "blacksite.pdb"))
+        );
+
+        let without_symbols = BuiltArtifacts {
+            executable,
+            companions: Vec::new(),
+        };
+        assert!(
+            select_debug_symbols(&profile, "x86_64-pc-windows-msvc", &without_symbols)
+                .unwrap_err()
+                .contains("PDB")
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn build_profile_default_scene_must_pass_scene_validation() {
+        let root = fixture_root();
+        fs::create_dir_all(root.join("assets/levels/custom")).unwrap();
+        fs::write(
+            root.join("assets/levels/custom/bad.scn.ron"),
+            "(schema_version:999,resources:{},entities:{})",
+        )
+        .unwrap();
+        let profile: BuildProfile = ron::from_str(
+            "(version:1,name:\"Bad Scene\",cargo_profile:Release,target:None,features:[],rendering_tier:\"shipping\",default_scene:Some(\"assets/levels/custom/bad.scn.ron\"),output_dir:\"dist/release\")",
+        )
+        .unwrap();
+        let error = validate_profile(&root, &profile).unwrap_err();
+        assert!(error.contains("default scene"), "{error}");
+        assert!(error.contains("schema"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn build_profile_default_scene_cannot_use_an_excluded_tree() {
+        let root = fixture_root();
+        fs::write(
+            root.join("assets/build_profiles/hidden.scn.ron"),
+            "(schema_version:2,resources:{},entities:{})",
+        )
+        .unwrap();
+        let profile: BuildProfile = ron::from_str(
+            "(version:1,name:\"Excluded\",cargo_profile:Release,target:None,features:[],rendering_tier:\"shipping\",default_scene:Some(\"assets/build_profiles/hidden.scn.ron\"),output_dir:\"dist/release\")",
+        )
+        .unwrap();
+        let error = validate_profile(&root, &profile).unwrap_err();
+        assert!(error.contains("assets/levels"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn packaged_project_settings_apply_profile_default_scene() {
+        let root = fixture_root();
+        let path = root.join("full-project.ron");
+        let source = settings::ProjectSettings {
+            default_level: "assets/levels/old.scn.ron".into(),
+            ..Default::default()
+        };
+        fs::write(
+            &path,
+            ron::ser::to_string_pretty(&source, ron::ser::PrettyConfig::default()).unwrap(),
+        )
+        .unwrap();
+        let source_bytes = fs::read(&path).unwrap();
+        let bytes = packaged_project_settings(
+            &source_bytes,
+            Some("assets/levels/profile-default.scn.ron"),
+            RenderingTier::Development,
+        )
+        .unwrap();
+        let packaged: settings::ProjectSettings =
+            ron::from_str(std::str::from_utf8(&bytes).unwrap()).unwrap();
+        assert_eq!(
+            packaged.default_level,
+            "assets/levels/profile-default.scn.ron"
+        );
+        assert_eq!(packaged.rendering.gi_mode, settings::GiMode::Forward);
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn failed_staging_does_not_modify_previous_package() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(&output).unwrap();
+        fs::write(output.join("blacksite"), b"old").unwrap();
+        mark_owned_output(&output);
+        let source = root.join("new-game");
+        fs::write(&source, b"new").unwrap();
+
+        let staging_path;
+        {
+            let pending = PendingPackage::new(&output).unwrap();
+            staging_path = pending.path().to_path_buf();
+            pending.seed_from(&output).unwrap();
+            copy_if_changed(
+                &source,
+                &pending.path().join("blacksite"),
+                &mut CopyStats::default(),
+            )
+            .unwrap();
+        }
+
+        assert_eq!(fs::read(output.join("blacksite")).unwrap(), b"old");
+        assert!(!staging_path.exists());
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn publishing_replaces_complete_package_and_removes_staging() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(&output).unwrap();
+        fs::write(output.join("obsolete"), b"old").unwrap();
+        mark_owned_output(&output);
+        let mut pending = PendingPackage::new(&output).unwrap();
+        let staging_path = pending.path().to_path_buf();
+        fs::write(pending.path().join("blacksite"), b"new").unwrap();
+        mark_owned_output(pending.path());
+
+        pending.publish(&output).unwrap();
+
+        assert_eq!(fs::read(output.join("blacksite")).unwrap(), b"new");
+        assert!(!output.join("obsolete").exists());
+        assert!(!staging_path.exists());
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn nonempty_unowned_output_is_never_replaced() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(&output).unwrap();
+        fs::write(output.join("user-notes.txt"), b"keep").unwrap();
+
+        let error = PendingPackage::new(&output).err().unwrap();
+
+        assert!(error.contains("unowned output"), "{error}");
+        assert_eq!(fs::read(output.join("user-notes.txt")).unwrap(), b"keep");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn package_lock_prevents_concurrent_publication_and_releases_cleanly() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        let lock = PackageLock::acquire(&output).unwrap();
+
+        let error = PackageLock::acquire(&output).err().unwrap();
+        assert!(error.contains("another build may be active"), "{error}");
+        drop(lock);
+
+        PackageLock::acquire(&output).unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn unrecognized_lock_file_is_preserved_and_rejected() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(root.join("dist")).unwrap();
+        let lock_path = root.join("dist/.blacksite-release.lock");
+        fs::write(&lock_path, b"user notes").unwrap();
+
+        let error = PackageLock::acquire(&output).err().unwrap();
+
+        assert!(error.contains("unrecognized package lock"), "{error}");
+        assert_eq!(fs::read(&lock_path).unwrap(), b"user notes");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn symlinked_lock_file_never_truncates_its_target() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(root.join("dist")).unwrap();
+        let outside = root.join("user-file");
+        fs::write(&outside, b"keep me").unwrap();
+        symlink(&outside, root.join("dist/.blacksite-release.lock")).unwrap();
+
+        let error = PackageLock::acquire(&output).err().unwrap();
+
+        assert!(error.contains("symlinked package lock"), "{error}");
+        assert_eq!(fs::read(&outside).unwrap(), b"keep me");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn interrupted_staging_is_removed_and_backup_is_restored() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(root.join("dist")).unwrap();
+        let staging = root.join("dist/.blacksite-release-1-2-0.staging");
+        fs::create_dir_all(&staging).unwrap();
+        write_work_marker(&staging, &output).unwrap();
+        fs::write(staging.join("partial"), b"partial").unwrap();
+        let backup = root.join("dist/.blacksite-release-1-2-0.backup");
+        fs::create_dir_all(&backup).unwrap();
+        fs::write(backup.join("blacksite"), b"previous").unwrap();
+        mark_owned_output(&backup);
+
+        recover_interrupted_package(&output).unwrap();
+
+        assert!(!staging.exists());
+        assert!(!backup.exists());
+        assert_eq!(fs::read(output.join("blacksite")).unwrap(), b"previous");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn unowned_staging_directory_is_never_scavenged() {
+        let root = fixture_root();
+        let output = root.join("dist/release");
+        fs::create_dir_all(root.join("dist")).unwrap();
+        let staging = root.join("dist/.blacksite-release-notes.staging");
+        fs::create_dir_all(&staging).unwrap();
+        fs::write(staging.join("notes.txt"), b"keep").unwrap();
+
+        let error = recover_interrupted_package(&output).unwrap_err();
+
+        assert!(error.contains("unowned staging"), "{error}");
+        assert_eq!(fs::read(staging.join("notes.txt")).unwrap(), b"keep");
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn runtime_asset_symlinks_are_rejected() {
+        use std::os::unix::fs::symlink;
+
+        let root = fixture_root();
+        let outside = root.join("outside.bin");
+        fs::write(&outside, b"outside").unwrap();
+        symlink(&outside, root.join("assets/external.bin")).unwrap();
+        let error = runtime_asset_sources(&root).unwrap_err();
+        assert!(error.contains("symlinks are not supported"), "{error}");
+        fs::remove_dir_all(root).unwrap();
+    }
+}
diff --git a/xtask/src/validate_levels.rs b/xtask/src/validate_levels.rs
index 5def98f..30fe4e7 100644
--- a/xtask/src/validate_levels.rs
+++ b/xtask/src/validate_levels.rs
@@ -1,26 +1,54 @@
-//! Validate all level scenes under assets/levels/ (H2 CI helper).
+//! Validate project content through the same report consumed by the editor.
 
-use std::path::Path;
-use walkdir::WalkDir;
+use std::path::PathBuf;
 
 fn main() {
-    let mut errors = 0;
-    for entry in WalkDir::new("assets/levels").into_iter().flatten() {
-        let path = entry.path();
-        if path.extension().is_some_and(|ext| ext == "ron") {
-            if let Err(err) = validate_level_file(path) {
-                eprintln!("{}: {err}", path.display());
-                errors += 1;
+    let mut project_root = PathBuf::from(".");
+    let mut json = false;
+    let mut args = std::env::args().skip(1);
+    while let Some(argument) = args.next() {
+        match argument.as_str() {
+            "--json" => json = true,
+            "--project" => {
+                let Some(path) = args.next() else {
+                    eprintln!("validate-levels: --project requires a path");
+                    std::process::exit(2);
+                };
+                project_root = PathBuf::from(path);
+            }
+            _ => {
+                eprintln!("validate-levels: unknown argument `{argument}`");
+                std::process::exit(2);
             }
         }
     }
-    if errors > 0 {
-        eprintln!("validate-levels: {errors} file(s) failed");
+
+    let report = scene::validate_project(&project_root);
+    if json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&report).expect("validation report must serialize")
+        );
+    } else {
+        for finding in &report.findings {
+            let actor = finding
+                .owner_actor_id
+                .as_deref()
+                .map(|actor| format!(" actor={actor}"))
+                .unwrap_or_default();
+            eprintln!(
+                "{:?} [{}] {}{}: {}",
+                finding.severity, finding.code, finding.source_path, actor, finding.message
+            );
+        }
+        println!(
+            "validate-levels: {} dependencies, {} findings, {} blocking errors",
+            report.dependencies.len(),
+            report.findings.len(),
+            report.blocking_error_count()
+        );
+    }
+    if !report.is_release_ready() {
         std::process::exit(1);
     }
-    println!("validate-levels: ok");
-}
-
-fn validate_level_file(path: &Path) -> Result<(), String> {
-    scene::validate_level_file(path)
 }